java - 集合

Collection

Collection coll = new ArrayList();

        // add(Object e)：将元素e添加到集合coll中
        coll.add("aa");
        coll.add("bb");
        coll.add(123);
        coll.add(new Date());

        // addAll(Collection c)：将c集合中的元素添加到当前集合中
        Collection coll1 = new ArrayList();
        coll1.add("aa");
        coll1.add("bb");
        coll.addAll(coll1);

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

        // clear()：清空当前集合中的元素
//        coll.clear();


        coll.add(new People("xiaoa"));
        // contains(Object obj)：判断当前集合是否包含obj。在判断时会调用obj对象所在类的eauals()
        System.out.println(coll.contains("aa"));
        System.out.println(coll.contains(new People("xiaoa")));// 调用equals()

        // containsAll(collection c)：判断形参C中所有元素是否都存在当前集合中
        System.out.println(coll.containsAll(coll1));

        // remove(Object o)：删除当前集合中的o元素
//        coll.remove("aa");
        // removeAll(collection c)：删除当前集合中所有和c集合的元素
//        coll.removeAll(coll1);


        // retainAll(Collection c):获取当前集合和c集合的交集，并返回给当前集合
        Collection coll2 = Arrays.asList("aa","bb","cc");
//        System.out.println(coll.retainAll(coll2));

        // equals(Collection c)：判断当前对象和c集合所有元素是否相等
        System.out.println(coll.equals(coll1));

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

        // toArray()：集合转换为数组
        Object[] toArray = coll.toArray();
        for (int i = 0; i < toArray.length; i++) {
            System.out.println(toArray[i]);
        }
        // asList() 数组转换集合
        List<String> stringList = Arrays.asList(new String[]{"aa", "bb","dd"});
        System.out.println(stringList);

        System.out.printf("_______________________");
        // iterator():返回Iterator实例，用于遍历集合元素.迭代器
        Iterator iterator = coll.iterator();
        // hasNext() 判断是否有下一个元素
        // next() 指针下移，返回当前元素
        // remove() 删除元素

//      //  Object next = iterator.next();
//      //  System.out.println(iterator.next());
//      //  for (int i = 0; i < coll.size(); i++) {
//      //      System.out.println(iterator.next());
//      //  }
        while (iterator.hasNext()){
            Object next = iterator.next();
            if("aa".equals(next)){
                iterator.remove();
            }
        }
        Iterator iterator1 = coll.iterator();
        while (iterator1.hasNext()){
            Object next = iterator1.next();
            System.out.println(next);
        }

        // foreach循环 for(元素的类型 元素变量 : 循环对象){}
        for (Object obj: coll) {

        }

List

// List接口
        // ArrayList：List接口的主要实现类。线程不安全
        // LinkedList：使用双向链表，多用于频繁的插入、删除操作
        // Vector：线程安全
        ArrayList list = new ArrayList();
        list.add("122");
        list.add(456);
        list.add(456);
        list.add(new People("suai"));
        System.out.println(list);

        // add(int index,Object obj) 在index索引位置插入obj元素
        list.add(2,"aa");
        System.out.println(list);

        // addAll(int index,Collection coll) 将coll中的所有元素添加到当前index位置中
        List list1 = Arrays.asList(4, 5);
        list.addAll(1,list1);
        System.out.println(list);

        // get(int index) 获取index位置元素
        System.out.println(list.get(2));

        // indexOf(Object obj)返回obj在当前集合第一次出现的位置
        System.out.println(list.indexOf(new People("suai")));

        // lastIndexOf(Object obj) 返回当前集合中obj元素最后出现的位置
        System.out.println(list.lastIndexOf(456));

        // remove(int index) 删除指定位置的元素，并返回此元素
        Object o = list.remove(2);
        System.out.println(o);
        System.out.println(list);

        // set(int index , object obj) 把集合中index位置元素设置为obj
        list.set(0,"77");
        System.out.println(list);

        // subList(int fromIndex , int toIndex)返回从fromIndex到toindex位置的子集合
        List list2 = list.subList(1, 5);
        System.out.println(list2);
        System.out.println(list);

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

Set

// Set接口
        // HashSet Set接口的主要实现类 线程不安全的 可以存储null值
        // LinkedHashSet HashSet的子类，遍历内部数据时，可以按照添加的顺序遍历
        // TreeSet 使用红黑树，可以按照添加对象的指定属性进行排序,
        //           TreeSet中添加的数据需要相同类的对象
        //          两种排序方式 自然排序(compreable) 定制排序(comparator)
        //          自然排序：比较两个对象是否相同的标准为，compareTo()返回0

        TreeSet treeSet = new TreeSet();
//        treeSet.add(1);
//        treeSet.add(81);
//        treeSet.add(78);
//        treeSet.add(4);
        treeSet.add(new People("uiyda"));
        treeSet.add(new People("qwekj"));
        treeSet.add(new People("cvs"));
        treeSet.add(new People("qwer"));
        System.out.println(treeSet);
        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());

        }

        Comparator com = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if (o1 instanceof People && o2 instanceof People){
                    People p1 = (People) o1;
                    People p2 = (People) o2;
                    return -p1.name.compareTo(p2.name);
                }else{
                    throw new RuntimeException("类型不一致");
                }
            }
        };

        TreeSet treeSet1 = new TreeSet(com);
        treeSet1.add(new People("uiyda"));
        treeSet1.add(new People("qwekj"));
        treeSet1.add(new People("cvs"));
        treeSet1.add(new People("qwer"));
        System.out.println(treeSet1);
        Iterator iterator1 = treeSet1.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());

        }

Map

// HashMap Map的主要实现类 可以存储null的key和valua
        Map map = new HashMap();
        // put(Object key , Object value) 将指定key-vlaue添加修改到当前集合中
        map.put(null,null);
        map.put("aa","AA");
        map.put("bb",456);
        map.put(new Peoples("xiaox"),"aa");
        map.put("aa","BB");

        // putAll(map m) 将集合m中的所有key-value添加到当前集合中
        HashMap map1 = new HashMap();
        map1.put("aa","Cc");
        map1.put(45,"45");
        map1.put("AA","aa");
        map.putAll(map1);

        // remove(Object key) 删除当前集合中指定key的键值对，并返回value
        Object remove = map.remove(null);
        System.out.println(remove);

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

        // get(Object key) 获取指定key的value值
        System.out.println(map.get("aa"));
        System.out.println(map.get("tt"));

        // containsKey(Object key) 是否包含指定key
        System.out.println(map.containsKey("aa"));

        // containsValue(Object value) 是否包含指定value
        System.out.println(map.containsValue(45));

        // size() 返回当前集合的键值对个数
        System.out.println(map.size());

        // isEmpty() 判断当前map是否为空
        System.out.println(map1.isEmpty());

        // keySet() 返回所有key构成的Set集合
        System.out.println(map.keySet());

        // values() 返回所有value构成的Collection集合
        System.out.println(map.values());

        // entrySet() 返回所有key-value对构成的Set集合
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Object o = iterator.next();
            Map.Entry entry = (Map.Entry) o;
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }

        System.out.println(map);
// 向TreeMap中添加key-value 要求key必须是同一类型对象
        // 因为要按照key排序

 // Properties 常用来处理配置文件 key和value都是String类型
        Properties properties = new Properties();
        FileInputStream fis = new FileInputStream("jdbc.properties");
        properties.load(fis);
        String name = properties.getProperty("name");
        String passWord = properties.getProperty("passWord");
        System.out.println(name + passWord);