java 集合collection

最新推荐文章于 2024-05-18 16:42:38 发布

z_healthy

最新推荐文章于 2024-05-18 16:42:38 发布

阅读量477

点赞数 26

文章标签： java 排序算法算法

本文链接：https://blog.csdn.net/w96098/article/details/138349452

版权

java.util.Collection

Collection：

java.util.Collection:

1、一个一个的数据；
2、常用子接口：
- (1)List：存储有序的可重复的数据；
  - ①具体实现类：ArrayList
    - Add AddAll

 public static void main(String[] args) {
        /* Add AddAll*/
        Collection arr = new ArrayList();
        arr.add(1); //自动装箱；
        arr.add("asd");
        arr.add(true);
        arr.add(new Object());
        arr.add(new Q());
        System.out.println(arr);
        Collection arr2 = new ArrayList();
        arr2.addAll(arr);
        System.out.println(arr2);
		System.out.println(arr.isEmpty());
        System.out.println(arr.size());
	
		 System.out.println(arr.contains(1));
       	 System.out.println(arr.contains(new Q())); //false;

		Collection arr2 = new ArrayList();
        System.out.println(arr.containsAll(arr2)); //是否包含arr2中的所有元素；
    }

remove clear

// remove  clear
 public void test2(){
        Collection arr = new ArrayList();
        arr.add(1);
        arr.clear();
        System.out.println(arr);
        arr.add(1);
        arr.add(1);
        arr.add("sad");
        System.out.println(arr);    //[1,1,sad]
        arr.remove(1);
        System.out.println(arr);    //[1,sad]

        Collection arr2 = new ArrayList();
        arr.removeAll(arr2);

    }

toArray/ hashcode 、retainAll

	public void test3(){
        /* toArray/ hashcode 、retainAll */
        Collection arr = new ArrayList();
        Collection arr2 = new ArrayList();
        arr.add(1);
        arr.add(2);
        System.out.println(arr.toArray());
        System.out.println(Arrays.toString(arr.toArray()));
        arr.retainAll(arr2);    //交集
        System.out.println(arr.hashCode());
    }

集合与数组相互装换


    @Test
    public void test4(){
        /* Arrays.asList */
        List<int[]> list = Arrays.asList(new int[]{1, 2});
        Collection arr = Arrays.asList(new String[]{""});
        /* toArray */
        arr.toArray();
    }

Iterator 迭代器，遍历集合元素

 
    @Test
    public void test5(){
        /**/
        Collection arr = new ArrayList();
        arr.add(1);
        arr.add("asdf");

        Iterator iterator = arr.iterator();
        //、、方式1
//        System.out.println(iterator.getClass());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.hasNext());
//        System.out.println(iterator.next());
        /*遍历*/
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

5.0新特性，增强for循环

    @Test
    public void test6(){
        /*可以遍历集合等*/
        Collection arr = new ArrayList();
        arr.add(1);
        arr.add("a");
        arr.add(true);
        for(Object obj: arr){
            System.out.println(obj);
        }
        /*可以遍历数组*/
        String[] arr2 = new String[]{"1","2"};
        for(String str: arr2){
            System.out.println(str);
        }
        /*底层调用的iterator；断点调试可见*/
    }
}

(2)Set：无序的，不可重复的；
- ①具体实现类：xxx

Map：java.util.Map

1、一对对的数据；(键值对）
2、具体实现类：HashMap 等；

public void test(){
        HashMap map = new HashMap();
        /* 增加 */
        map.put(null, null);
        System.out.println(map);
        Map map2 = new HashMap();
        map2.put("name", "zhangsan");
        /* 修改 */
        map2.put("name", "lisi");
        System.out.println(map2);
        /* 删除(有返回值) */
        map.remove(null);
        /* 移除不存在的值，无问题 */
        map.remove(null);
        System.out.println(map);
    }

@Test
    public void test2(){
        Map map = new Hashtable();
//        map.put("key", null); //空指针；
    }
    @Test
    public void test3(){
        LinkedHashMap map = new LinkedHashMap();
        map.put("name","name");
        map.put("age","12");
        System.out.println(map);
        /* 查 */
        System.out.println(map.get("age"));
    }

@Test
    public void test4(){
        Map map = new HashMap();
        map.put("name", "zhangsan");
        map.put("age", "12");
        map.put("gender", "0");
        map.put(new Object(), 1);
        map.put(1, 1);
        System.out.println(map);
        Object value = map.get("age"); //
        Object value2 = map.get(1); // 装箱；
        /* 遍历key */
        Set keySet = map.keySet();
        Iterator iterator = keySet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("============");
        /* 遍历value */
        Collection values = map.values();
        for(Object item: values){
            System.out.println(item);
        }
    }

强制类型转换、 entrySet

public void test5(){
        /* entrySet */
        Map map = new HashMap();
        map.put("name", "zhangsan");
        map.put("age", "12");
        map.put("gender", "0");
        map.put(new Object(), 1);
        map.put(1, 1);

        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
//            Object next = iterator.next();

            /* 强制类型转换 */
            Map.Entry entry = (Map.Entry) iterator.next();
            System.out.println(entry.getKey() + "===>" + entry.getValue());
        }
    }

List :

1、可以替换数组：
2、长度是可变的；
3、主要的实现类： ArrayList;

package com.healthy.collection.collection_20230804;

import org.junit.Test;

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

/**
 * @Date 2023/8/4 16:03
 * @Discrition
 */
public class ListTest {
    @Test
    public void test1(){
        List list = new ArrayList();
        List list2 = new ArrayList();
        list2.add(10);
        list.add(1);
        list.add("2");
        list.add(true);
        Object obj = new Object();
        list.add(obj);
        /*插入*/
        list.add(2, false); //插入到index之前；
        list.addAll(3, list2); //插入到index之前；
        System.out.println(list.toString()); //还是基于迭代器的tostring

        list.remove(2);     //移除index；
//        list.remove(String.valueOf(2));  //- -/
//        list.remove("2");  //- -/

        System.out.println(list);
    }
    @Test
    public void test2(){
        List list = new ArrayList();
        list.add(5);
        list.add(8);
        list.add(7);
        list.add(6);
        System.out.println(list);
        /* remove的多态 */
//        list.remove((Integer) 8);
//        list.remove(new Integer(8));
        list.remove(Integer.valueOf(8));
        System.out.println(list);
        /*循环*/
        /*迭代器*/
        Iterator iterator = list.iterator();
//        while (iterator.hasNext()) {
//            System.out.println(iterator.next());
//        }
        /* 加强for循环 */
//        for(Object obj: list){
//            System.out.println(obj);    //Integer 包装类；
//        }
        /* 因为index而加 */
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
    @Test
    public void test3(){
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        Object obj = list.get(1);
        list.set(1,list.get(2));
        list.set(2, obj);
        System.out.println(list);
    }
}

List 中的常用方法见代码：ListTest；

实现类的区别；

ArrayList：
- 主要实现类；（线程不安全=》效率高）
- 1、查找效率高，增删效率低；
Vector：
- 古老实现类：（线程安全=》效率低）
- 1、即使有线程安全问题，也不用这个；
两个底层都是Object[] 数组存储；

LinkedList:

1、底层使用双向链表的方式存储；
2、双向链表：上知下，下知道上；
3、频繁删除、插入推荐此类；
4、增删效率高，查找效率低；

Set:

1、主要实现类： hashSet；
2、接口Set中的常用方法和Collection一致，
3、也是用来过滤重复数据的；
4、会过滤重复数据；（使用的hash算法）
5、Hash算法导致的无序性；

 @Test
    public void test1(){
        Set set = new HashSet();
        set.add(1);
        set.add(2);
        set.add("3");
        set.add(true);
        set.add(new Object());
        set.add(new Object());
        set.add(3);
        set.add(3);

        System.out.println(set);    //无序性； 但不是随机的；
        //[1, 2, 3, java.lang.Object@17d10166, true]
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

 @Test
    public void test2(){
        Set set = new LinkedHashSet();
        set.add(1);
        set.add(2);
        set.add("3");
        set.add(true);
        set.add(new Object());
        set.add(new Object());
        set.add(3);
        set.add(3);

        System.out.println(set);    //linked 有序性；
        // [1, 2, 3, 3, java.lang.Object@17d10166, java.lang.Object@1b9e1916, true]
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

LinkedhashSet

1、是HashSet的子类；
2、基于HashMap添加了一组双向链表，用于记录添加元素的先后顺序；
3、之后可按照添加元素的先后顺序进行遍历；
4、便于频繁的查询操作；（遍历）

HashMap:

1、jdk8中，使用的是数组+单向链表+红黑树的数据额结构；
2、

TreeSet：

1、数组中的item类型必须相同；
2、自带排序功能；
3、类型相同才可比较；
4、如果以object类型作为item；则object必须实现Comparable接口
5、及接口中的compareTo方法；

public class TreeSetTest {
    @Test
    public void test1(){
        TreeSet treeSet = new TreeSet();
        treeSet.add(1);
        treeSet.add(123);
        treeSet.add(13);
        treeSet.add(9);
        treeSet.add(32);
        treeSet.add(101);
        treeSet.add(19);
//        treeSet.add("AA");        //只能是同一个类型；
        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        /* treeSet实现了compareable接口，默认有排序能力 */
    }
}

Map

Map接口：

1、主要类

(1)HashMap：主要实现类；
- ①=> 线程不安全，效率高；
- ②可以添加key或value为null的值；
- ③底层：数组+单向链表+红黑树结构；
- ④Key-value 特点：
  - 1)Key是不相同，且无序的；
  - 2)Key的集合其实可以说是一个set；
  - 3)Value是可以相同的；可以说是collection；
  - 4)一个key-value 构成了一个entry；
  - 5)所有的entry是不可重复，无序的；且构成一个set集合；
  - 6)无序的就不存在指定位置的插入；
- ⑤子类： linkedHashMap
  - 1)对比hashmap增加了双向链表；
  - 2)用于记录添加的先后顺序；
  - 3)遍历时可以按照添加的顺序来显示；
  - 4)频繁遍历，使用此类；
(2)Hashtable: 古老实现类
- ①=> 线程安全，效率低；
- ②不可以添加null为key或者value；
- ③底层：数组+单向链表；
- ④子类：Properties
  - 1)是一个map；
  - 2)Key和value是string类型；
  - 3)主要用来处理属性文件；
(3)TreeMap:
- ①底层使用的红黑树存储：（排序二叉树）
- ②可以按照key进行排序遍历；

2、区别？

方法：增删改查，长度，遍历；

TreeMap

TreeMap:

1、自然排序： key需要实现compareable 或compareto方法；
2、Key为Object类型可以重写compareable 或compareto方法自定义排序；
3、Comparetor订制排序；
4、Key必须是同一个类型；

public void test(){
        TreeMap map = new TreeMap();

        map.put("A", 1);
        map.put("F", 11);
        map.put("D", 12);
        map.put("S", 16);
        map.put("H", 18);
        // map.put(1,1);   //ClassCastException; 和之前的key数据类型不一致；
        map.put("J", 14);

        Set set = map.entrySet();
        for (Object obj: set){
            /* key自然排序 */
            System.out.println(obj);
        }
    }

public void test2(){
        /* 订制排序，再看 */
        Comparator comparator = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };
        TreeMap map = new TreeMap(comparator);
        map.put("A", 1);
        map.put("F", 11);
        map.put("D", 12);
        map.put("S", 16);
        map.put("H", 18);
        Set set = map.entrySet();
        for (Object obj: set){
            /* key自然排序 */
            System.out.println(obj);
        }
    }

Hashtable

略

Properties

继承自HashTable
1)是一个map；
2)Key和value是string类型；
3)主要用来处理属性文件；

结合io流使用；无例子；

public void test1(){
        Properties properties = new Properties();
        /* 需要接口File.io流使用； */
        /* 用来处理文件属性内容 */
    }

工具类：Collections

用途：

1、set/list/map等集合的工具类；

乱序，自动排序（定制化）

 public void test1(){
        List list  = Arrays.asList(1,2,3,4,5,6,7);
        /* fanzhuan */
        Collections.reverse(list);
        System.out.println(list);
        /* 乱序 */
        Collections.shuffle(list);
        System.out.println(list);
        /* 自动排序 */
        Collections.sort(list);
        System.out.println(list);
        /* 订制话 */
        Collections.sort(list, new Comparator() {

            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
//                int v = i1.intValue() - i2.intValue();
                int v = i2.intValue() - i1.intValue();
                return v;
                /** if(o1 instanceof Integer) {

                }else {
                        throw new RuntimeException("bupipeide leixing");
                }
                 */
            }
        });
        System.out.println(list);
    }

    public void test2(){
        List list  = Arrays.asList(1,2,3,4,5,6,7);
//        List list2 = new ArrayList();
        //IndexOutOfBoundsException: Source does not fit in dest
        List list2 = Arrays.asList(new Object[list.size()]);
        Collections.copy(list2,list);

        System.out.println(list2);
    }
    @Test
    public void test3(){
        List list  = Arrays.asList(1,2,3,4,5,6,7);
        /*不可修改*/
        List list2 = Collections.unmodifiableList(list);
        System.out.println(list2);

        /*线程安全*/
        List list3 = Collections.synchronizedList(list);

        Collections.rotate(list, -2);
        System.out.println(list);
    }