java 集合collection

java.util.Collection

Collection:

java.util.Collection:

  • 1、一个一个的数据;
  • 2、常用子接口:
    • (1)List: 存储有序的可重复的数据;
      • ①具体实现类:ArrayList

        • Add AddAll
java 复制代码
 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
java 复制代码
// 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
java 复制代码
	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());
    }
  • 集合与数组相互装换
java 复制代码
    @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 迭代器,遍历集合元素
java 复制代码
 
    @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循环
java 复制代码
    @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 等;
java 复制代码
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);
    }
java 复制代码
@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"));
    }
java 复制代码
@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
java 复制代码
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;
java 复制代码
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算法导致的无序性;
java 复制代码
 @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());
        }
    }
java 复制代码
 @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方法;
java 复制代码
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必须是同一个类型;
java 复制代码
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);
        }
    }
java 复制代码
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流使用;无例子;

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

工具类:Collections

用途:

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

  • 乱序,自动排序(定制化)
java 复制代码
 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);
    }
java 复制代码
    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);
    }

方法:

  • 1、基本都是静态方法;
  • 2、Reverse
  • 3、Shuffle
  • 4、Sort
  • 5、Swap
  • 6、
相关推荐
陈王卜10 分钟前
django+boostrap实现发布博客权限控制
java·前端·django
小码的头发丝、11 分钟前
Spring Boot 注解
java·spring boot
java亮小白199716 分钟前
Spring循环依赖如何解决的?
java·后端·spring
飞滕人生TYF22 分钟前
java Queue 详解
java·队列
VertexGeek27 分钟前
Rust学习(八):异常处理和宏编程:
学习·算法·rust
石小石Orz27 分钟前
Three.js + AI:AI 算法生成 3D 萤火虫飞舞效果~
javascript·人工智能·算法
武子康44 分钟前
大数据-230 离线数仓 - ODS层的构建 Hive处理 UDF 与 SerDe 处理 与 当前总结
java·大数据·数据仓库·hive·hadoop·sql·hdfs
武子康1 小时前
大数据-231 离线数仓 - DWS 层、ADS 层的创建 Hive 执行脚本
java·大数据·数据仓库·hive·hadoop·mysql
苏-言1 小时前
Spring IOC实战指南:从零到一的构建过程
java·数据库·spring
界面开发小八哥1 小时前
更高效的Java 23开发,IntelliJ IDEA助力全面升级
java·开发语言·ide·intellij-idea·开发工具