Collection集合、Collections工具类

集合框架概述

1.集合、数组都是对多个数据进行存储操作的结构，简称java容器
此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg数据库中）

2.数组在存储多个数据方面

(1)特点:一旦初始化后，长度确定；元素数据类型确定，只能操作指定类型的数据；如：String[ ]、Object[ ] arr2
(2)缺点：
a.一旦初始化，长度不可修改；
b.数组提供的方法有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高；
c.获取数组中实际元素个数的需求，数组没有现成的属性和方法；
d.数组有序、可重复，对于无序、不可重复需求，不能满足

java集合分为Collection和Map两种体系

Collection接口：单列数据，定义存取一个一个对象的方法集合
1. List接口:有序，可重复（动态数组）

|--------------------ArrayList：作为List的主要实现类，线程不安全，效率高；底层使用Object[ ]存储、
|--------------------LinkedList：对于频繁的插入、删除操作，其比ArrayList高；底层使用“双向链表”存储
|--------------------Vector：作为List接口的古老实现类，线程安全，效率低；底层使用Object[ ]存储

2.Set接口:无序，不可重复（数学中的“集合”），操作过滤问题，即相同数据过滤掉

|--------------------HashSet：作为Set接口的主要实现类；线程不安全；可以存储null值
|-------------------------------LinkedHashSet：在HashSet基础上添加了Link，是HashSet的子类，使其在遍历内部数据时，可以按照添加的顺序遍历（不同于有序）
|--------------------TreeSet：可以按照添加对象的指定属性进行排序


Collection接口
Map:双列数据，保存具有映射关系”key-value对“的集合（数学中函数y=f(x)）

|------HashMap：Map的主要实现类，线程不安全，效率高；可以存储null（jdk7之前，底层数组+链表；jdk8，数组+链表+红黑树）
|--------------------LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。原因：在原有HashMap的底层结构基础上，添加了一堆指针，指向前一个和后一个元素，对于频繁的遍历操作，执行效率高于HashMap
|------TreeMap：按照添加的key-value对进行排序，实现排序遍历。其中key的排序为自然排序或定制排序；底层使用的红黑树
|------Hashtable：古老的实现类，线程安全，效率低；不能存储null
|--------------------Properties：常用来处理配置文件，其中key和value都是String


Map接口
Collection接口中声明方法的测试

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()

        Collection c1 = new ArrayList();
        c1.add(new Person("xiaohong",12));
        c1.add(new Person("xiaohong",12));
        //false,未重写equals方法时:即Object的equals方法相当于==，基本数据类型，比较值；引用数据，比较地址
//        System.out.println(c1.contains(new Person("xiaohong", 12)));
        System.out.println(c1.contains(new Person("xiaohong", 12)));//true,重写equals方法时，即比较值
        Collection c2 = Arrays.asList(12);
        System.out.println(c1.containsAll(c2));

下列方法操作的对象:

        Collection c1 = new ArrayList();
        c1.add(12);//表示数字
        c1.add("12");//表示字符串
        c1.add(new Person("xiaohong",12));
        c1.add(new Person("xiaohong",12));

        Collection c2 = Arrays.asList(12,13);

(1)retainAll(Colection coll):交集

System.out.println(c1.retainAll(c2));//true,两个集合的交集
System.out.println(c1);//[12]  交集后输出c1

(2)removeAll(Collection coll):差集

 System.out.println(c1.removeAll(c2));//true,移除c1中存在的c2，即差集
 System.out.println(c1);//[12, com.vv.string.Person@0, com.vv.string.Person@0]

(3)hashCode():哈希值

 //返回当前对象的哈希值
        System.out.println(c1.hashCode());

(4)toArray():集合--》数组

        //1.集合---->数组
        Object[] objects = c1.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.print(objects[i] + "\t");
        }
        System.out.println();

        //2.数组----->集合
        List<Object> objects1 = Arrays.asList(objects);
        System.out.println(objects1);//[12, 12, com.vv.string.Person@0, false]

        //a.基本数据类型数组--->集合  将数组整体存入
        List<int[]> ints = Arrays.asList(new int[]{123, 145});
        System.out.println(ints);//[[I@5d6f64b1] int型的一维数组
        System.out.println(ints.size());//1

        //b.包装类的数组--->集合
        List<Integer> integers = Arrays.asList(new Integer[]{12, 45});
        System.out.println(integers);//[12, 45]
        System.out.println(integers.size());//2
(5)Iterator(迭代器)

1.主要用于遍历Collection集合中的元素；
2.Collection接口继承了java.lang.Iterable接口，该接口有一个iterator方法，因此所有实现了Collection接口的集合都有一个iterator方法，用来返回一个实现了iterator接口的对象
3.Iterator仅用于遍历集合，其本身并不提供承装对象的能力；但若需要创建Iterator对象，则必须有一个被迭代的集合
4.每次调用iterator方法都会得到一个全新的迭代器对象


迭代器执行原理

两种错误的迭代方式：

 // 错误方式一：结果跳着输出且NoSuchElementException
        Iterator iterator = c1.iterator();
        while(iterator.next() != null){
            System.out.println(iterator.next());//
        }

//每次c1.iterator().hasNext()都会创建新的迭代器对象
//错误方式二：一直输出第一个位置的值
        while (c1.iterator().hasNext()){
            System.out.println(c1.iterator().next());
        }

(6)remove(Object obj)

Iterator iterator = c1.iterator();
        while (iterator.hasNext()){
           if("13".equals(iterator.next())){//????数字如何和迭代器元素比较
                iterator.remove();
            }
//            System.out.print(iterator.next()+"\t");//出错，NoSuchElementException，原因是迭代器中元素改变了
        }
        Iterator iterator1 = c1.iterator();
            while (iterator1.hasNext()){
            System.out.print(iterator1.next()+"\t");//12    Person{name='xiaohong', age=14} false
        }
length、length()、size()区别

length——数组的属性；
length()——String的方法；
size()——集合的方法；

JDK5.0：ForEach遍历集合和数组

//for(集合元素类型 局部变量：集合对象)
for(Object obj:coll)

Iterator iterator1 = c1.iterator();
        for(Object c : c1){//内部仍然调用了迭代器
            System.out.print(iterator1.next()+"\t");
        }

例题

int[] arr = new int[]{112,3,4};
        //方式一赋值
        for (int i = 0; i < arr.length; i++) {
            arr[i] = 4;//对本身的数组元素进行修改
        }

        //方式二赋值
//        for(int a : arr){
//            a = 4;//取出来，重新对s赋值。在常量池中
//        }

        for(int a : arr){
            System.out.print(a + "\t");//方式一：4  4   4  方式二：112  3   4
        }

List接口

ArrayList、LinkedList、Vector三者异同
ArrayList

jdk7.0中的ArrayList对象的创建类似于单例的饿汉式，底层创建了长度为10的Object[ ]；而jdk8.0中的ArrayList对象的创建类似于单例的懒汉式，底层的Object[ ]初始化为{ },延迟了数组创建，节省内存
扩容2倍

LinkedList

内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。其中Node用于保存数据，其prev和next两个变量分别记录前一个和后一个元素
扩容1.5倍

List接口中常用方法

List中:remove(int index)

        ArrayList list = new ArrayList();
        list.add(12);
        list.add("xiaohong");
        list.add(new Person("hh",10));
        list.add(false);

        System.out.println(list.remove(2));//Person{name='hh', age=10}

区别Colection中:remove(Object o)

        c1.add("20");//表示字符串
        c1.add(new Person("xiaohong",12));

        System.out.println(c1.remove("20"));//true
        System.out.println(c1);//[Person{name='xiaohong', age=12}]

subList(begin end)类似于String中的subString(begin end)都是左开右闭

List中主要方法

增/插add删remove改set查get长度size()遍历（1）Iterator（2）forEach（3）普通循环
例题：remove考察

@Test
    public void test1(){
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);

        updateList(list);
        System.out.println(list);

    }
    void updateList(List list){
//        list.remove(2);//[1 ,2] 删除索引位置的值
        list.remove(new Integer(2));//[1,3]  删除该对象
    }

Set接口中的方法

Set接口中没有额外定义的新方法，使用的都是Collection中声明过的方法（无序即代表没有索引）
List接口中有额外定义的新方法，因为List中有索引（有顺序即代表有索引）

HashSet论证Set的无序性，并不是代表随机性

HashSet存储数据时，底层数组并非按照数组索引的顺序添加，而是根据数组的哈希值确定
不可重复性：保证添加的元素按照equals()判断时，不能返回true，即相同的元素只能添加一个

 @Test
    public void test(){
        Set set = new HashSet();
        set.add(12);
        set.add("hh");
        set.add(new Person("zhangsan",10));
        set.add(new Person("zhangsan",10));

        System.out.println(set);
    }

添加元素：以HashSet（其底层是数组+链表）为例：
向HashSet中添加元素a，先调用hashCode，计算其哈希值，然后哈希值接着通过某种计算方法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素：若没有，则a添加成功；若有元素b，首先比较a，b的哈希值，若哈希值不相同，则a添加成功；若相同，进而需要调用元素a所在类的equals方法，equals返回true，a添加失败。返回false，a添加成功
对于a添加时其位置有元素而言，a和已经存在于指定索引位置上的数据之间以链表方式存储（jdk7，a放到数组中，指向原来的元素；jdk8，原来的元素在数组中，指向元素a）


HashSet底层结构
Set set = new HashSet();
        set.add(12);
        set.add("hh");
        set.add(new Person("zhangsan",10));
        set.add(new Person("zhangsan",10));
//        //当未重写equals和hasCode时
//        System.out.println(set);//[hh, Person{name='zhangsan', age=10}, 12, Person{name='zhangsan', age=10}]

//        //当只重写equals时
//        System.out.println(set);//[hh, Person{name='zhangsan', age=10}, 12, Person{name='zhangsan', age=10}]

        //当只重写hasCode时
        System.out.println(set);//[hh, Person{name='zhangsan', age=10}, 12, Person{name='zhangsan', age=10}]

//        //当重写equals和hasCode时
//        System.out.println(set);//[hh, Person{name='zhangsan', age=10}, 12]
向Set中添加的数据，其所在的类必须进行hashCode和equals重写，重写的hashCode和equals尽可能保持一致性，相等的对象必须具有相等的散列码（hashCode）
LinkedHashSet底层结构
LinkedHashSet

作为HashSet的子类，在添加数据时，每个数组还维护了两个引用，记录此数据的前后数据，其对于“频繁的遍历操作”，LinkedHashSet频率高于HashSet


LinkedHashSet
TreeSet

1.向TreeSet添加数据，必须是相同的对象;
2.排序方式自然排序、定制排序

自然排序：

两对象进行比较时，为CompareTo方法，不再是equals方法

Set set = new TreeSet();
/*
        TreeSet中存放不同对象出错java.lang.Integer cannot be cast to java.lang.String

        set.add(12);
        set.add("hh");
        set.add(new Person("xiao",15));
        System.out.println(set);
*/
        /*
        //1.基本数据类型存储，默认从小到大排序
        set.add(12);
        set.add(32);
        set.add(2);
        System.out.println(set);//[2, 12, 32]
        */
        //2.对象存储，
        /*
         未对对象实现Comparable,重写CompareTo方法，即并未告知TreeSet以对象的哪种属性进行排序
         com.vv.string.Person cannot be cast to java.lang.Comparable
        */

        set.add(new Person("hong",15));
        set.add(new Person("wang",5));
        set.add(new Person("zhang",35));
        set.add(new Person("zhang",25));

        /*在Person中实现Comparable接口时，对属性进行按照指定大小进行排序*/
//        //当仅对name属性进行比较时
//        System.out.println(set);//[Person{name='hong', age=15}, Person{name='wang', age=5}, Person{name='zhang', age=35}]

        //当对name和age属性进行比较时
        System.out.println(set);//[Person{name='hong', age=15}, Person{name='wang', age=5}, Person{name='zhang', age=25}, Person{name='zhang', age=35}]

定制排序:Comparator

Set set = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof  Person && o2 instanceof Person){
                    return -Integer.compare(((Person) o1).age,((Person) o2).age);
                    //[Person{name='zhang', age=35}, Person{name='zhang', age=25}, Person{name='hong', age=15}, Person{name='wang', age=5}]
                }else{
                    throw new RuntimeException("对象类型不一致");
                }

            }
        });

例题：
1.属性排序

//生日排序
 @Test
    public void test(){
        Employee e1 = new Employee("xiaohong",12,new MyDate(1926,2,6));
        Employee e2 = new Employee("zhangsan",82,new MyDate(1823,3,7));
        Employee e3 = new Employee("lisi",62,new MyDate(1926,5,6));
        Employee e4 = new Employee("zhaoliu",12,new MyDate(1753,2,9));
        Employee e5 = new Employee("dawei",18,new MyDate(1926,5,3));

        //使用Comparator對生日進行排序
        TreeSet set = new TreeSet(new Comparator() {
            @Override
        public int compare(Object o1, Object o2) {

            if (o1 instanceof Employee && o2 instanceof Employee) {
                Employee e1 = (Employee) o1;
                Employee e2 = (Employee) o2;

                MyDate m1 =  e1.getBirthday();
                MyDate m2 = e2.getBirthday();

                /*//方式一:直接在该方法中比较
                int year = m1.getYear() - m2.getYear();
                //比较年
                if (year != 0) {
                    return Integer.compare(m1.getYear(), m2.getYear());
                }
                int month = m1.getMonth() - m2.getMonth();
                //比较月
                if (month != 0) {
                    return Integer.compare(m1.getMonth(), m2.getMonth());
                }
                //比较日
                    return Integer.compare(m1.getDay(), m2.getDay());*/

                //方式二：在MyDate中实现Comparable接口
                return m1.compareTo(m2);
            }

            throw new RuntimeException("對象不一致");
        }

    });
//        TreeSet set = new TreeSet();
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);

//        Iterator iterator = set.iterator();
        for(Object o : set ){
            System.out.println(o);

        }

    }

//name排序的同时，按照生日排序
//在Person类中比较
@Override
    public int compareTo(Object o) {
        if(o instanceof  Employee){
            Employee e = (Employee) o;

            int i =this.name.compareTo(e.getName());
            if(i == 0){
                return this.getBirthday().compareTo(e.getBirthday());
            }else{
                return i;
            }
}
        throw new RuntimeException("对象类型不一致");
    }

2.在List内去除重复元素

 public static void main(String[] args) {
        List list = new ArrayList();

        list.add(new Integer(2));
        list.add(new Integer(2));
        list.add(new Integer(1));
        List list1 = updateSet(list);

        for(Object o : list1){
            System.out.print(o + "\t");
        }
//        for (int i = 0; i < list.size(); i++) {
//            System.out.println(list.get(i));
//        }

    }
    public static List updateSet(List list){
        HashSet set = new HashSet();
        //若list中添加的是自定义对象，则需要进行hashCode重写；Integer的equals方法已经重写了
        set.addAll(list);
        return new ArrayList(set);
    }

3.set***********太坑了

HashSet set = new HashSet();
        Person p1 = new Person("AA",11);
        Person p2 = new Person("BB",22);

        set.add(p1);
        set.add(p2);

        p1.setName("CC");
        set.remove(p1);

        // 首先算出此时name为CC和age为11的哈希值，再与name为AA和age为11的哈希值比较，结果不等；
        // 因此，此时删除的位置其实为空，故存储结果为[Person{name='BB', age=22}, Person{name='CC', age=11}]，
        System.out.println(set);

        set.add(new Person("CC",11));
        //name为CC和age为11的位置存储添加的数据，其中结果的值，一个为AA所在位置的值替换，另一个为新的位置
        // [Person{name='BB', age=22}, Person{name='CC', age=11}, Person{name='CC', age=11}]
        System.out.println(set);

        //虽然AA的位置仍在，但通过equals比较时发现，两者对象不一样，因此使用链表重新指向
        //[Person{name='BB', age=22}, Person{name='CC', age=11}, Person{name='CC', age=11}, Person{name='AA', age=11}]
        set.add(new Person("AA",11));
        System.out.println(set);

Map接口

Map中的key：无序、不可重复，使用Set存储所有的key--》key所在类要重写equals和hashCode方法（例如：containsKey需要重写equals和hashCode）
Map中的value：无序、可重复，使用Collection存储所有的value--》value所在类要重写equals方法（例如：containsValue需要重写equals方法）
一个键值对：key-value构成了一个Entry对象。
Map中的entry：无序、不可重复，使用Set存储所有的entry


jdk7的HashMap底层原理

jdk8的HashMap底层原理

map元试图操作方法：

 Map map = new HashMap();
        map.put(1,2);
        map.put(null,3);
        map.put("AA",9);

        //遍历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();
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }

        //遍历key-value
        //方式一：
        Set entrySet = map.entrySet();
        Iterator iterator2 = entrySet.iterator();
        while (iterator2.hasNext()){
            Object obj = iterator2.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey()+"......"+entry.getValue());
        }

        //方式二：
        Set set1 = map.keySet();
        Iterator iterator3 = set1.iterator();
        while (iterator3.hasNext()){
            Object obj = iterator3.next();
            Object value = map.get(obj);
            System.out.println(obj+"......"+value);
        }

TreeMap的key必须是同一个类创建的对象,因此要按照key排序：自然排序或者定制排序

        Map map = new TreeMap();
        map.put(new User("zhangsan",16),"shanxi");
        map.put(new User("lisan",16),"xian");
        map.put(new User("lisan",15),"dali");

        Set set = map.entrySet();
        Iterator iterator = set.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey()+"..........."+entry.getValue());
        }

Collections是一个操作Collection（Set、List）和Map等集合的工具类

注意：copy方法

 List list = new ArrayList();
        list.add(12);
        list.add(34);
        list.add(34);
        list.add(85);

//        //错误写法一：Source does not fit in dest，看源码后：list.size() > list1.size()
//        List list1 = new ArrayList();
//        Collections.copy(list1,list);

          //错误写法二：list1.size()为0，size()表示add后的数组长度
//        List list1 = new ArrayList(list.size());//表示的是数组的长度
//        Collections.copy(list1,list);

        //eg:
        List l = new ArrayList(9);//创建长度为9的数组
        System.out.println(l.size());//0

        List dest = Arrays.asList(new Object[list.size()]);
        Collections.copy(dest,list);
        System.out.println(dest);//[12, 34, 34, 85]

Collections中的synchronizedXxx()方法，可使指定集合包装成线程同步的集合，从而解决多线程并发问题

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 204,793评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,567评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,342评论 0赞 338
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,825评论 1赞 277
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,814评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,680评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,033评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,687评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 42,175评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,668评论 2赞 321
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,775评论 1赞 332
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,419评论 4赞 321
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,020评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,978评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,206评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,092评论 2赞 351
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,510评论 2赞 343

推荐阅读更多精彩内容

  • Java集合
    Java集合类可用于存储数量不等的对象,并可以实现常用的数据结构如栈,队列等,Java集合还可以用于保存具有映射关...
    小徐andorid阅读 1,915评论 0赞 13
  • Java 集合
    1 集合 1.1 集合介绍   集合是java中提供的一种容器，可以来存储多个数据。在前面的学习中，我们知道数据多...
    圣堂刺客_x阅读 300评论 0赞 0
  • java集合容器
    3.3 集合 一方面， 面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另...
    闫子扬阅读 715评论 0赞 1
  • java集合框架学习总结
    title: java集合框架学习总结 tags:集合框架 categories:总结 date: 2017-03...
    行径行阅读 1,674评论 0赞 2
  • java程序UAT的部署
    UAT预发布环境 环境准备 apache-maven-3.6.2apache-tomcat-8.5.50jdk1....
    夜醉梦紅尘阅读 945评论 0赞 4