本文将介绍休眠-如何映射EnumSet的详细情况，特别是关于设置映射的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于2021-11-05：摆动排序I

本文将介绍休眠-如何映射EnumSet的详细情况，特别是关于设置映射的相关信息。我们将通过案例分析、数据研究等多种方式，帮助您更全面地了解这个主题，同时也将涉及一些关于2021-11-05：摆动排序 II。给你一个整数数组 nums，将它重新排列成 nums[0] ＜ nums[1] ＞ nums[2] ＜ nums[3]... 的顺序。你可以假设所有输入数组都可以、Enum.values（）与EnumSet.allOf（）。哪一个更可取？、Enum.values（）与EnumSet.allOf（）哪一个更可取？、EnumSet到底是什么意思？的知识。

• 休眠-如何映射EnumSet（设置映射）
• 2021-11-05：摆动排序 II。给你一个整数数组 nums，将它重新排列成 nums[0] ＜ nums[1] ＞ nums[2] ＜ nums[3]... 的顺序。你可以假设所有输入数组都可以
• Enum.values（）与EnumSet.allOf（）。哪一个更可取？
• Enum.values（）与EnumSet.allOf（）哪一个更可取？
• EnumSet到底是什么意思？

休眠-如何映射EnumSet（设置映射）

我有一个颜色枚举

public enum color { GREEN, WHITE, RED }

我有包含它的MyEntity。

public class MyEntity {   private Set<Color> colors;   ...

我已经有一个UserType来映射我的枚举。
您知道如何在Hibernate hbm.xml中映射枚举集吗？
我需要一个UserType还是最简单的方法？
谢谢

编辑： 只是为了说明一下，我正在寻找 hbm.xml 配置而不是@CollectionOfElements注释

答案1

我使用EnumSet映射线程中的解决方案，该解决方案依赖于的使用<elementcolumn>。您只需要一个具有ID和字符串的表即可映射集合（MYENTITY_COLOR此处）。映射看起来像这样（这EnumUserType是Java
5
EnumUserType中的映射）：

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping>    <typedef name="color">        <param name="enumClassName">com.stackoverflow.q2402869.Color</param>    </typedef>    <class name="com.stackoverflow.q2402869.MyEntity" entity-name="MyEntity" table="MYENTITY">        <id name="id" type="java.lang.Long">            <column name="ID" />            <generator/>        </id>        <set name="colors" table="MYENTITY_COLORS">            <key column="ID" not-null="true"/>            <element type="color" column="COLOR"/>        </set>    </class></hibernate-mapping>

查询可能如下所示：

select distinct e from MyEntity e join e.colors colors where colors IN (''WHITE'', ''GREEN'')

整个解决方案适用 于加载，保存和查询 （归于jasonab）。

2021-11-05：摆动排序 II。给你一个整数数组 nums，将它重新排列成 nums[0] ＜ nums[1] ＞ nums[2] ＜ nums[3]... 的顺序。你可以假设所有输入数组都可以

2021-11-05：摆动排序 II。给你一个整数数组 nums，将它重新排列成 nums[0] < nums[1] > nums[2] < nums[3]… 的顺序。你可以假设所有输入数组都可以得到满足题目要求的结果。力扣324。

福大大 答案2021-11-05：

需要了解快排和完美洗牌问题。
时间复杂度：O(N)。
空间复杂度：O(1)。

代码用golang编写。代码如下：

package main

import (
    "fmt"
    "math/rand"
)

func main() {
   
    nums := []int{
   1, 5, 1, 1, 6, 4}
    wiggleSort(nums)
    fmt.Println(nums)
}

// 时间复杂度O(N)，额外空间复杂度O(1)
func wiggleSort(nums []int) {
   
    if len(nums) < 2 {
   
        return
    }
    N := len(nums)
    // 小 中 右
    findIndexNum(nums, 0, len(nums)-1, N/2)
    if (N & 1) == 0 {
   
        // R L -> L R
        shuffle(nums, 0, len(nums)-1)
        // R1 L1 R2 L2 R3 L3 R4 L4
        // L4 R4 L3 R3 L2 R2 L1 R1 -> 代码中的方式，可以的！
        // L1 R1 L2 R2 L3 R3 L4 R4 -> 课上的分析，是不行的！不能两两交换！
        reverse(nums, 0, len(nums)-1)
        // 做个实验，如果把上一行的code注释掉(reverse过程)，然后跑下面注释掉的for循环代码
        // for循环的代码就是两两交换，会发现对数器报错，说明两两交换是不行的, 必须整体逆序
        // for (int i = 0; i < nums.length; i += 2) {
   
        // swap(nums, i, i + 1);
        // }
    } else {
   
        shuffle(nums, 1, len(nums)-1)
    }
}

func findIndexNum(arr []int, L int, R int, index int) int {
   
    pivot := 0
    var range2 []int
    for L < R {
   
        //pivot = arr[L+(int)(Math.random()*(R-L+1))]
        pivot = arr[L+rand.Intn(R-L+1)]
        range2 = partition(arr, L, R, pivot)
        if index >= range2[0] && index <= range2[1] {
   
            return arr[index]
        } else if index < range2[0] {
   
            R = range2[0] - 1
        } else {
   
            L = range2[1] + 1
        }
    }
    return arr[L]
}

func partition(arr []int, L int, R int, pivot int) []int {
   
    less := L - 1
    more := R + 1
    cur := L
    for cur < more {
   
        if arr[cur] < pivot {
   
            less++
            //swap(arr, ++less, cur++);
            arr[less], arr[cur] = arr[cur], arr[less]
            cur++
        } else if arr[cur] > pivot {
   
            more--
            //swap(arr, cur, --more);
            arr[more], arr[cur] = arr[cur], arr[more]
        } else {
   
            cur++
        }
    }
    return []int{
   less + 1, more - 1}
}

func shuffle(nums []int, l int, r int) {
   
    for r-l+1 > 0 {
   
        lenAndOne := r - l + 2
        bloom := 3
        k := 1
        for bloom <= lenAndOne/3 {
   
            bloom *= 3
            k++
        }
        m := (bloom - 1) / 2
        mid := (l + r) / 2
        rotate(nums, l+m, mid, mid+m)
        cycles(nums, l-1, bloom, k)
        l = l + bloom - 1
    }
}

func cycles(nums []int, base int, bloom int, k int) {
   
    for i, trigger := 0, 1; i < k; i, trigger = i+1, trigger*3 {
   
        next := (2 * trigger) % bloom
        cur := next
        record := nums[next+base]
        tmp := 0
        nums[next+base] = nums[trigger+base]
        for cur != trigger {
   
            next = (2 * cur) % bloom
            tmp = nums[next+base]
            nums[next+base] = record
            cur = next
            record = tmp
        }
    }
}

func rotate(arr []int, l int, m int, r int) {
   
    reverse(arr, l, m)
    reverse(arr, m+1, r)
    reverse(arr, l, r)
}

func reverse(arr []int, l int, r int) {
   
    for l < r {
   
        arr[l], arr[r] = arr[r], arr[l]
        l++
        r--
    }
}

执行结果如下：

左神java代码

Enum.values（）与EnumSet.allOf（）。哪一个更可取？

我仔细研究了EnumSet.allOf它，它看起来非常高效，尤其是对于值小于64的枚举。

基本上，所有集合共享所有可能的枚举值的单个数组，而唯一的另一条信息是位掩码，如果allOf设置为一，则将其设置为。

另一方面，Enum.values（）似乎有点黑魔法。此外，它返回一个数组，而不是一个集合，因此在许多情况下，必须用Arrays.asList（）装饰它，以便在任何需要集合的地方使用。

那么，应该EnumSet.allOf更可取Enum.values吗？

更具体地说，for应使用哪种形式的迭代器：

for ( final MyEnum val: MyEnum.values( ) );

要么

for ( final MyEnum val: EnumSet.allOf( MyEnum.class ) );

答案1

因为我没有收到哪个问题的答案更有效，所以我决定自己做一些测试。

我测试过的迭代过values()，Arrays.asList( values() )和EnumSet.allOf()。对于不同的枚举大小，我已经重复了这些测试10,000,000次。测试结果如下：

oneValueEnum_testValues         1.328oneValueEnum_testList           1.687oneValueEnum_testEnumSet        0.578TwoValuesEnum_testValues        1.360TwoValuesEnum_testList          1.906TwoValuesEnum_testEnumSet       0.797ThreeValuesEnum_testValues      1.343ThreeValuesEnum_testList        2.141ThreeValuesEnum_testEnumSet     1.000FourValuesEnum_testValues       1.375FourValuesEnum_testList         2.359FourValuesEnum_testEnumSet      1.219TenValuesEnum_testValues        1.453TenValuesEnum_testList          3.531TenValuesEnum_testEnumSet       2.485TwentyValuesEnum_testValues     1.656TwentyValuesEnum_testList       5.578TwentyValuesEnum_testEnumSet    4.750FortyValuesEnum_testValues      2.016FortyValuesEnum_testList        9.703FortyValuesEnum_testEnumSet     9.266

这些是从命令行运行的测试结果。当我从Eclipse运行这些测试时，我获得了压倒性的支持testValues。基本上，它EnumSet甚至比小枚举都小。我相信性能的提高来自for( val : array )循环中数组迭代器的优化。

另一方面，一旦您需要传递一个java.util.Collection，就会将其放Arrays.asList()为EnumSet.allOf，特别是对于小的枚举，我相信在任何给定的代码库中，枚举都是主要的。

所以，我说你应该使用

for ( final MyEnum val: MyEnum.values( ) )

但

Iterables.filter(    EnumSet.allOf( MyEnum.class ),    new Predicate< MyEnum >( ) {...})

仅Arrays.asList( MyEnum.values( ) )在java.util.List绝对需要的地方使用。

Enum.values（）与EnumSet.allOf（）哪一个更可取？

for ( final MyEnum val: MyEnum.values( ) );

for ( final MyEnum val: EnumSet.allOf( MyEnum.class ) );

EnumSet到底是什么意思？

我有以下示例：

import java.util.EnumSet;import java.util.Iterator;public class SizeSet {    public static void main(String[] args) {        EnumSet largeSize = EnumSet.of(Size.XL,Size.XXL,Size.XXXL);        for(Iterator it = largeSize.iterator();it.hasNext();){            Size size = (Size)it.next();            System.out.println(size);        }    }}enum Size {  S, M, L, XL, XXL, XXXL;}

在这段代码中，我可以理解Enum创建了一个Enum类型的Sizes。

我的问题是：largeSizeEnumSet类型的对象吗？到底是什么意思 我真的很想更好地理解它。

答案1

对于任何变量，可以在其声明中找到其类型：

EnumSet largeSize

是的，largeSize（应该命名，largeSizes因为它是一个集合）是type EnumSet。它也应该被泛化，因此被声明为

EnumSet<Size> largeSizes

它的意思是那largeSizes是type
EnumSet。一个EnumSet是一个Set包含一个特定的枚举类型的枚举例如，在比其他更有效的方式Set实现（如HashSet，TreeSet等）。要知道是什么EnumSet，请阅读其API。

今天关于休眠-如何映射EnumSet和设置映射的分享就到这里，希望大家有所收获，若想了解更多关于2021-11-05：摆动排序 II。给你一个整数数组 nums，将它重新排列成 nums[0] ＜ nums[1] ＞ nums[2] ＜ nums[3]... 的顺序。你可以假设所有输入数组都可以、Enum.values（）与EnumSet.allOf（）。哪一个更可取？、Enum.values（）与EnumSet.allOf（）哪一个更可取？、EnumSet到底是什么意思？等相关知识，可以在本站进行查询。