栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

JavaSE06-集合

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

JavaSE06-集合

集合 Collection接口 概述

数组和集合都是Java中提供的容器

集合: 英文译为 Collection,用来存放对象的容器,集合中可以存放不同类型的对象,并且集合的长度可变。

在编程时,常常需要集中存放多个数据,可以使用数组来保存多个对象,但数组长度不可变化,一旦在初始化数组时指定了数组长度,这个数组长度就是不可变的,如果需要保存数量变化的数据,数组就有点无能为力了;

为了保存数量不确定的数据,以及保存具有映射关系的数据,Java提供了集合类。集合类主要负责保存、盛装其他数据,因此集合类也被称为容器类。

小结: 集合和数组的对比:

1)数组中的元素可以基本类型的值,也可以是对象; 而集合中只能保存对象

2)数组一旦指定了长度,长度就不能再改变; 而集合的长度是可以随时改变的

3)往数组中插入元素非常麻烦,需要将插入位置后面的元素往后移动; 或者删除数组中间位置的某一个元素, 需要将删除位置后的元素往前移动; 而如果往集合中插入元素或者删除集合中的某一个元素,直接使用现成的方法操作即可

集合的继承结构

由于需求不同,Java就提供了不同的集合类。这多个集合类的数据结构不同,但是它们都是要提供存储和遍历功能的,我们把它们的共性不断的向上提取,最终就形成了集合的继承体系结构图。

Collection接口

|-- List接口

​ |-- ArrayList类

​ |-- LinkedList类

|-- Set接口

​ |-- HashSet类

​ |-- TreeSet类

解释说明:

- Collection集合是所有单值集合的顶层接口, 其中定义了常用的用于操作集合以及集合中元素的方法

例如: 添加元素、删除元素、获取元素、获取集合长度、判断功能、将集合转成数组、迭代器遍历元素等功能

- List是Collection的子接口,特点是其中的元素是有序的(即:元素存入集合时的顺序和取出的顺序一致)

可以通过下标访问List中的元素,另,List集合中的元素是可以重复的(包括null)

- Set也是Collection的子接口,特点是其中的元素是无序(即:元素存入集合时的顺序和取出的顺序不一定一致)

无法通过下标访问Set中的元素,另外,Set集合中的元素是不可以重复的

学习集合的建议:

- 学习接口中提供的共性方法

- 通过实现类创建对象, 调用这些共性方法

常用方法

​ !!boolean add(E e)

​ – 往集合中添加指定元素e

​ boolean addAll(Collection c)

​ – 将小集合添加到大集合中

​ !!boolean isEmpty()

​ – 如果集合中没有任何元素(空集合), 返回true

​ boolean contains(Object o)

​ – 如果此集合中包含指定元素o, 则返回true

​ boolean containsAll(Collection c)

​ – 如果此集合中包含指定 集合c 中的所有元素,则返回 true。

​ – 例如c1中有 “a”,“b”,“c”,“d”, 而c2中有"a",“b”, 则c1包含c2, 返回true

​ 若,c1中有 “a”,“b”,“c”,“d”, 而c2中有"x",“a”,“b”, 则c1不包含c2, 返回false

​ !!int size()

​ – 返回集合的大小(元素个数)

​ !!boolean remove(Object o)

​ – 从集合中删除指定的元素o, 删除成功则返回true

​ – 如果删除的元素不存在导致删除失败, 则返回false

​ – 如果元素o在集合中出现多次,仅删除第一个

​ boolean removeAll(Collection c)

​ – 删除此集合中那些也包含在指定集合c中的所有元素, 若有共同元素, 则删除并返回true

​ 例如 c1中有 “a”,“b”,“c”,“d”, 而c2中有"x",“a”,“b”,

​ c1.removeAll(c2),只删除c1中两个共同的元素 “a”,“b”, 对c2没有影响

​ – 如果两个集合中没有共同元素, 则不删除, 返回false

boolean retainAll(Collection c)

​ – 仅保留此集合中那些也包含在指定集合c中的元素

​ 例如 c1中有 “a”,“b”,“c”,“d”, 而c2中有"x",“a”,“b”,

​ c1.retainAll(c2),只保留c1中两个共同的元素 “a”,“b”, 对c2没有影响

​ void clear()

​ – 删除此集合中的所有元素

​ Object[] toArray()

​ – 将此集合转成对象数组

​ boolean equals(Object o)

​ – 比较此 collection 与指定对象是否相等。

​ !!Iterator iterator()

​ – 返回此集合中所有元素组成的迭代器。

实例1:CollectionDemo1
package Part06Collection;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;


public class CollectionDemo1 {
    public static void main(String[] args) {
        //集合中只能存放引用类型
        Collection c = new ArrayList();
        
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        c.add(123);//c.add(Integer.valueOf(123)) 会触发自动装箱特性
        System.out.println(c);//[one, two, three, four, five]
        
        int size = c.size();
        System.out.println("集合的元素个数:"+size);
        
        boolean isEmpty = c.isEmpty();
        System.out.println("集合是否为空:"+isEmpty);
        //清空集合 把集合变为空集合
        c.clear();
        System.out.println(c);
        System.out.println("集合的元素个数:"+c.size());
        System.out.println("集合是否为空:"+c.isEmpty());
    }
}
实例2:CollectionDemo2
package Part06Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;

public class CollectionDemo2 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        //Collection c = new HashSet();//不可以重复存储相同的元素
        c.add(new Point(1, 2));
        c.add(new Point(3, 4));
        c.add(new Point(5, 6));
        c.add(new Point(7, 8));
        c.add(new Point(9, 0));
        c.add(new Point(1, 2));
        
        System.out.println(c);
        Point p = new Point(1, 2);
        
        boolean contains = c.contains(p);
        System.out.println("当前集合是否包含该元素:"+contains);
        
        c.remove(p);
        System.out.println(c);
    }
}
Point
package Part06Collection;

import java.util.Objects;

public class Point {
    private int x;
    private int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
    //alt+insert 选择equals and hashCode,然后一路回车即可
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}
实例3:CollectionDemo3

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nZXhVxuU-1654135210710)(pic/image-20220521094249618.png)]

package Part06Collection;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo3 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        Point p = new Point(1, 2);
        c.add(p);//将p元素添加到集合中
        System.out.println("p:"+p);
        System.out.println("c:"+c);

        p.setX(2);//将p对象的x属性修改为2
        System.out.println("p:"+p);
        System.out.println("c:"+c);
    }
}
实例4:CollectionDemo4
package Part06Collection;

import java.util.ArrayList;
import java.util.Collection;


public class CollectionDemo4 {
    public static void main(String[] args) {
        Collection c1 = new ArrayList();
        c1.add("java");
        c1.add("c++");
        c1.add(".net");
        System.out.println("c1:"+c1);
        Collection c2 = new ArrayList();
        c2.add("android");
        c2.add("ios");
        c2.add("java");
        System.out.println("c2:"+c2);
        
        boolean b = c1.addAll(c2);
        System.out.println(b);
        System.out.println("c1:"+c1);
        System.out.println("c2:"+c2);
        Collection c3 = new ArrayList();
        c3.add("c++");
        c3.add("java");
        //c3.add("php"); //不加php,就返回true,加了php,就返回false
        
        boolean b1 = c1.containsAll(c3);
        System.out.println("包含所有:"+b1);
        
        c1.retainAll(c3);
        System.out.println("c1:"+c1);
        System.out.println("c3:"+c3);
        
        c1.removeAll(c3);
        System.out.println("c1:"+c1);
        System.out.println("c3:"+c3);
    }
}
集合的遍历 IteratorDemo
package Part06Collection;

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


public class IteratorDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("one");
        c.add("#");
        c.add("two");
        c.add("#");
        c.add("three");
        c.add("#");
        c.add("four");
        c.add("#");
        c.add("five");
        System.out.println(c);
        //获取迭代器对象
        Iterator it = c.iterator();
        
        while (it.hasNext()){
            String e = (String) it.next();
            System.out.println(e);
            if("#".equals(e)){
                
                //c.remove(e);
                
                it.remove();
            }
        }
        System.out.println(c);
    }
}
增强型for循环 NewForDemo
package Part06Collection;

import java.util.ArrayList;
import java.util.Collection;


public class NewForDemo {
    public static void main(String[] args) {
        String[] array = {"one","two","three","four","five"};
        //传统for循环遍历数组
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        //新循环遍历数组 array.for
        for (String s : array){
            System.out.println(s);
        }
        Collection c = new ArrayList();
        c.add("一");
        c.add("二");
        c.add("三");
        c.add("四");
        c.add("五");
        for (Object o : c){
            String str = (String)o;
            System.out.println(str);
        }
        //新循环底层遍历就是迭代器遍历,编译器会将其改回迭代器遍历,
        //所以我们如果想删除集合中的元素时,这种新循环就不适合了
        for (String s : c) {
            System.out.println(s);
        }
    }
}
List集合 概述

List是一个有序的Collection(List是Collection的子接口),使用此接口能够精确的控制每个元素插入的位置,能够通过索引(类似于数组的下标)来访问List中的元素,第一个元素的索引为 0,而且允许有相同的元素。

List 接口存储一组可重复、有序(插入顺序)的对象。

特点
  1. 元素有下标,可以通过下标访问元素

  2. 元素是有序的(存入集合的顺序和取出的顺序一定相同)

  3. 元素可以重复(包括null)

List方法测试 ListDemo
package Part06Collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;


public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        System.out.println(list);
        //获取集合中的第三个元素
        
        String str = list.get(2);//与数组获取元素的功能一致 String str = arr[2]
        System.out.println(str);
        //由于list集合有下标,所以可以使用for循环遍历
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        
        //[one, six, three, four, five]
        String old = list.set(1, "six");//将第二个位置原来的two替换为six,并将two返回
        System.out.println(old);
        System.out.println(list);
        //在不创建新的集合的前提下,将集合元素翻转
        
        for (int i=0;i//i:0 1
            //获取正数位置上的元素
            String e = list.get(i);//one
            //将获取到的正数位置的元素替换到倒数位置上
            e = list.set(list.size()-1-i, e);
            //将原倒数位置上的元素替换到正数位置上
            list.set(i, e);
        }
        System.out.println(list);
        Collections.reverse(list);//翻转集合
        System.out.println(list);
    }
}
ListDemo2
package Part06Collection;

import java.util.ArrayList;
import java.util.List;


public class ListDemo2 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("一");
        list.add("二");
        list.add("三");
        list.add("四");
        list.add("五");
        System.out.println(list);
        
        list.add(3,"老六儿");
        System.out.println(list);
        
        String old = list.remove(2);
        System.out.println(old);
        System.out.println(list);
    }
}
ListDemo3
package Part06Collection;

import java.util.ArrayList;
import java.util.List;


public class ListDemo3 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        //向集合中添加0-9的元素
        for (int i=0;i<10;i++){
            list.add(i);
        }
        System.out.println(list);
        //获取子集[3-7] 含头不含尾
        List sub = list.subList(3, 8);
        System.out.println(sub);
        //将子集中的每个元素都扩大10倍
        for (int i = 0; i < sub.size(); i++) {
            sub.set(i, sub.get(i)*10);
        }
        System.out.println(sub);
        //对子集的操作就是对原集合对应元素的操作
        System.out.println(list);
        //清除集合中1-8这部分元素
        list.subList(1, 9).clear();
        System.out.println(list);
    }
}
集合和数组的转换 集合转换数组:CollectionToArrayDemo
package Part06Collection;

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


public class CollectionToArrayDemo {
    public static void main(String[] args) {
        Collection c = new ArrayList<>();
        c.add("老大");
        c.add("二娃");
        c.add("三弟");
        c.add("四兄");
        c.add("五妹");
        System.out.println("集合:"+c);
        //Object[] array = c.toArray();
        //需要传入一个指定长度的对应类型的数组
        String[] array = c.toArray(new String[c.size()]);
        System.out.println("数组:"+ Arrays.toString(array));
    }
}
数组转换集合: ArrayToListDemo
package Part06Collection;

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


public class ArrayToListDemo {
    public static void main(String[] args) {
        String[] array = {"one","two","three","four","five"};
        System.out.println("数组:"+ Arrays.toString(array));
        List list = Arrays.asList(array);
        System.out.println("集合:"+list);
        //对该集合的操作就是对原数组对应的操作,也就是改了集合数组也会跟着改
        list.set(1, "six");//将下标1的元素覆盖为six
        System.out.println("集合:"+list);
        System.out.println("数组:"+ Arrays.toString(array));
        
        //list.add("seven");
        System.out.println("集合:"+list);
        System.out.println("数组:"+ Arrays.toString(array));
        
        //List list2 = new ArrayList<>();
        //list2.addAll(list);
        
        List list2 = new ArrayList<>(list);
        list2.add("seven");
        System.out.println(list2);
    }
}
集合的排序 SortListDemo
package Part06Collection;

import java.util.*;


public class SortListDemo {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            //每次向集合中添加一个100以内的随机整数
            list.add(random.nextInt(100));
        }
        System.out.println(list);
        Collections.sort(list);//自然排序,从小到大
        System.out.println(list);
    }
}
SortListDemo2
package Part06Collection;

import java.util.*;


public class SortListDemo2 {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(new Point(1, 2));
        list.add(new Point(15, 66));
        list.add(new Point(3, 4));
        list.add(new Point(9, 0));
        list.add(new Point(7, 8));
        System.out.println(list);
        
        //Collections.sort(list);
        //使用匿名内部类的形式创建一个比较器,可以使用泛型约束我们比较的是两个Point
        Comparator com = new Comparator() {
            
            @Override
            public int compare(Point o1, Point o2) {
                //点与点比较一般都是距离原点的距离越远,就越大
                int len1 = o1.getX()*o1.getX() + o1.getY()*o1.getY();
                int len2 = o2.getX()*o2.getX() + o2.getY()*o2.getY();
                return len1-len2;
            }
        };
        Collections.sort(list,com);
        System.out.println(list);
    }
}
Map接口 概述

Map用于保存具有映射关系的数据,因此Map集合里保存着两组值,一组值用于保存Map里的键(key)另外一组值用于保存Map里的值(value),键和值是一一对应的关系,称为映射。根据键就能找到对应的值,类似于生活中一张身份证对应一个人一样。

Map的key和value可以是任何引用类型的数据,其中key不允许重复,同一个Map对象的任何两个key通过equals方法比较总是返回false。

特点

1) Map集合中每个元素都有两个值, 分别是key(键) 和 value(值)

2) Map集合中的key(键)不允许重复, 在第二次添加已有的key时, value会被会覆盖

3) Map集合中的元素是无序的(即元素存入集合的顺序和取出时的顺序很可能不一致)

4) Map集合中的key和value具有映射关系, 可以通过key(键)来获取对应的value(值)

key和value之间存在单向一对一关系,即通过指定的key,总能找到唯一的、确定的value。从Map中取出数据时,只要给出指定的key,就可以取出对应的value。

如果把Map里的所有key放在一起来看,它们就组成了一个Set集合(所有的key没有顺序,key与key之间不能重复),实际上Map确实包含了一个keySet()方法,用于返回Map里所有key组成的Set集合。

如果把Map里的所有value放在一起来看,它们又非常类似于一个List:元素与元素之间可以重复,每个元素可以根据索引来查找,只是Map中的索引(也就是key)不是从0开始的整数值,而是任意类型的对象;

如果需要从List集合中取出元素,则需要提供该元素的数字索引;如果需要从Map中取出元素,则需要提供该元素的key。因此,Map有时也被称为字典,或关联数组。

继承结构

Map接口

|— HashMap类

|— TreeMap类

|— Hashtable类

解释说明:

- Map集合是采用键-值对(key-value)的存储方式, 键(key)、值(value)可以是引用类型的数据, key不允许重复, vaue可以重复, key和value是一对一的关系, 通过指定的key总能找到唯一的、确定的value值

- HashMap 和 Hashtable 都是Map接口的实现类,它们之间的关系完全类似于ArrayList和Vector的关系

1) HashMap是线程不安全的, 所以HashMap的性能要比HashTable高一些

2) HashMap可以使用null作为key或value, Hashtable不允许使用null作为key和value;

3) Hashtable是一个古老的Map实现类,JDK 1.0出现,出现时,Java还没有提供Map接口,命名没有遵守Java的命名规范,与Vector类似的是,尽量少用Hashtable实现类,即使需要创建线程安全的Map实现类,也无须使用Hashtable实现类,可以通过别的方式来解决线程安全问题。

- TreeMap是Map的子接口SortedMap的的实现类, 是可以支持对内部元素进行排序的类, 也正因为如此, TreeMap的执行效率通常要比HashMap和HashTable慢。

MapDemo
package Part06Collection;

import java.util.HashMap;
import java.util.Map;


public class MapDemo {
    public static void main(String[] args) {
        //Map声明时,可以指定泛型,不过需要指定两个类型,一个是key的类型,一个value的类型
        Map map = new HashMap();
        
        map.put("语文", 80);
        //map.put("数学", 70).intValue();
        
        Integer value = map.put("数学", 70);
        System.out.println("value:"+value);//如果key不存在,就返回null
        map.put("英文", 34);
        map.put("化学", 60);
        //{英文=34, 数学=70, 化学=60, 语文=80}
        System.out.println(map);
        //map在put时,如果key不存在,就直接存储,如果key存在,就会覆盖
        value = map.put("数学", 150);
        System.out.println("value:"+value);//如果key存在,返回被替换掉的元素
        System.out.println(map);
        
        Integer score = map.get("语文");
        System.out.println("语文成绩:"+score);
        score = map.get("体育");
        System.out.println("体育成绩:"+score);
        //返回map中的元素个数
        int size = map.size();
        System.out.println("集合中有"+size+"个元素");
        
        score = map.remove("数学");
        System.out.println("删除了数学成绩:"+score);
        size = map.size();
        System.out.println("集合中有"+size+"个元素");
        //可以分别判断Map中是否包含给定的key或者value
        boolean ck = map.containsKey("英文");
        System.out.println("是否包含key:"+ck);
        boolean cv = map.containsValue(100);
        System.out.println("是否包含value:"+cv);
    }
}
MapDemo2
package Part06Collection;

import java.util.*;


public class MapDemo2 {
    public static void main(String[] args) {
        Map map = new HashMap<>();
        map.put("语文", 98);
        map.put("数学", 100);
        map.put("英语", 80);
        map.put("物理", 60);
        map.put("java", 150);
        System.out.println(map);
        
        Set keySet = map.keySet();
        for (String s : keySet) {
            System.out.println("map的key是:"+s);
            System.out.println("map的value是:"+map.get(s));
        }
        
        Collection values = map.values();
        for (Integer value : values) {
            System.out.println("map的value是:"+value);
        }
        
        Set> entrySet = map.entrySet();
        for (Map.Entry entry : entrySet) {
            //从entry对象中获取key值
            String key = entry.getKey();
            //从entry对象中获取value值
            Integer value = entry.getValue();
            System.out.println("key:"+key+"===="+"value:"+value);
        }
        
        map.forEach(
                //此处k和v起什么名字无所谓,第一个值是key,第二个值是value
                (k,v)-> System.out.println(k+":"+v)
        );
        Collection c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        c.forEach(
                (e)-> System.out.println(e)
        );
        //如果参数只有一个,小括号可以省略
        c.forEach(
                e-> System.out.println(e)
        );
        //如果输出的参数和传入的参数都是一个,参数也可以省略,并且替换为::
        c.forEach(
                System.out::println
        );
    }
}
代码分析 Demo1
package Part06Collection;

import java.util.ArrayList;
import java.util.Collection;


public class Demo {
    public static void main(String[] args) {
        String s = "hello";
        int a = 1;
        Point p = new Point(1, 2);
        Collection c = new ArrayList();
        c.add(p);
        test(s, a, p, c);
        System.out.println("s:"+s);
        System.out.println("a:"+a);
        System.out.println("p:"+p);
        System.out.println("c:"+c);
    }
    public static void test(String s,int a,Point p,Collection c){
        a++;
        s= s + "world";
        p.setX(3);
        p = new Point(4, 5);
        c.clear();
        c.add(p);
        c = new ArrayList();
        p.setX(7);
        c.add(p);
    }
}
  • 执行test方法最后一行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2Erqsksa-1654135210713)(pic/image-20220523202224814.png)]

  • 执行完test方法,清空test方法的局部变量和引用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EdrAJqlP-1654135210714)(pic/image-20220523202200438.png)]

  • 清理堆中无引用对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BXCcDpZd-1654135210715)(pic/image-20220523202126267.png)]

Demo2
package Part06Collection;

import java.sql.SQLOutput;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;


public class Demo2 {
    public static void main(String[] args) {
        int a = 1;
        String str = "hello";
        Point p = new Point(1,2);
        String[] arr = {"one","two","three",str};
        int[] arr1 = {1,2,3,4,a};
        Point[] arr2 = {new Point(1,2),new Point(3,4),new Point(5,6),p};
        dosome(a,str,p,arr,arr1,arr2);
        System.out.println("a:"+a);
        System.out.println("str:"+str);
        System.out.println("p:"+p);
        System.out.println("arr:"+ Arrays.toString(arr));
        System.out.println("arr1:"+Arrays.toString(arr1));
        System.out.println("arr2:"+Arrays.toString(arr2));
    }
    public static void dosome(int a,String str,Point p,String[] arr,int[] arr1,Point[] arr2) {
        arr1[a] = 3;
        arr[a] = "str";
        arr[a+1] = str;
        str = "world";
        str = arr[2];
        str+="!!";
        p.setX(4);
        p = arr2[2];
        p.setX(6);
        arr2 = Arrays.copyOf(arr2, arr2.length-1);
        arr2[2].setX(8);
        arr2 = new Point[]{new Point(2,2),p};
        arr2[arr2.length-1].setX(12);
    }
}
  • 执行dosome方法之前

  • 执行dosome方法进行传参时

  • dosome方法执行完毕

  • dosome方法执行后,弹出相关局部变量,清除多余引用以及无引用对象

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/951251.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号