对于想了解如何确定对象是否是PySpark中的有效键值对的读者，本文将是一篇不可错过的文章，我们将详细介绍判断对象是否存在某个key，并且为您提供关于c#–如何确定对象引用是否为空？、c#–如何确定对
对于想了解如何确定对象是否是PySpark中的有效键值对的读者，本文将是一篇不可错过的文章，我们将详细介绍判断对象是否存在某个key，并且为您提供关于c# – 如何确定对象引用是否为空？、c# – 如何确定对象是否继承自抽象泛型类、c# – 确定对象是否是任何类型的数组,并访问数组长度、java – 反射性地检查对象是否是方法的有效泛型参数的有价值信息。
本文目录一览：- 如何确定对象是否是PySpark中的有效键值对（判断对象是否存在某个key）
- c# – 如何确定对象引用是否为空？
- c# – 如何确定对象是否继承自抽象泛型类
- c# – 确定对象是否是任何类型的数组,并访问数组长度
- java – 反射性地检查对象是否是方法的有效泛型参数
如何确定对象是否是PySpark中的有效键值对（判断对象是否存在某个key）
- 如果我有rdd，我如何理解数据为key：value格式？有没有办法找到相同的东西-像type（object）告诉我对象的类型。我试过了
print type(rdd.take(1))，但这只是说<type ''list''>。 - 假设我有一个类似的数据
(x,1),(x,2),(y,1),(y,3)，我使用groupByKey和得到了(x,(1,2)),(y,(1,3))。有没有一种方法可以将x和y定义 为键(1,2)和(1,3)值？还是键必须是单个值？我注意到，如果我使用reduceByKey和sum函数来获取数据，((x,3),(y,4))那么将这些数据定义为键值对变得容易得多
答案1
小编典典Python是一种动态类型化的语言，PySpark对键，值对不使用任何特殊类型。将对象视为PairRDD操作的有效数据的唯一要求是可以按以下方式解压缩对象：
k, v = kv通常，tuple由于其语义（固定大小的不可变对象）和与ScalaProduct类的相似性，您将使用两个元素。但这只是一个约定，没有什么可以阻止您执行以下操作：
key_value.py
class KeyValue(object): def __init__(self, k, v): self.k = k self.v = v def __iter__(self): for x in [self.k, self.v]: yield xfrom key_value import KeyValuerdd = sc.parallelize( [KeyValue("foo", 1), KeyValue("foo", 2), KeyValue("bar", 0)])rdd.reduceByKey(add).collect()## [(''bar'', 0), (''foo'', 3)]并使任意类的行为类似于 键值 。因此，如果可以将某事物正确地解压缩为一对对象，那么它就是有效的 键值
。实现方法__len__和__getitem__魔术方法也应该起作用。处理此问题的最优雅的方法可能是使用namedtuples。
还type(rdd.take(1))返回一个listlength，n因此其类型将始终相同。
c# – 如何确定对象引用是否为空？
这是以下吗？
MyObject myObjVar = null;
if (myObjVar == null)
{
// do stuff
}
解决方法
MyObject myObjVar;
if (myObjVar == null)
{
// do stuff
}
BTW：您的代码将不会编译现在的方式,因为myObjVar在初始化之前被访问.
c# – 如何确定对象是否继承自抽象泛型类
abstract class SuperClass<T> where T : SuperDataClass abstract class SuperDataClass
数据类型仅限于SuperDataClass,因此每个具体数据类型都必须从SuperDataClass继承.
最后我有一对SuperClass和SuperDataClass继承者,例如：
class DataClassA : SuperDataClass class ClassA : SuperClass<DataClassA> class DataClassB : SuperDataClass class ClassB : SuperClass<DataClassB>
如何检查对象是否存在,例如ClassA是否从SuperClass继承而不知道可能的数据类型？
我尝试了以下,但不起作用：
if (testObject.GetType().IsAssignableFrom(typeof(SuperClass<SuperDataClass>))) {
Console.WriteLine("The test object inherits from SuperClass");
}
那么if语句需要怎么样？
解决方法
Type type2 = type; // type is your type,like typeof(ClassA)
while (type2 != null)
{
if (type2.IsGenericType &&
type2.GetGenericTypeDeFinition() == typeof(SuperClass<>))
{
// found
}
type2 = type2.BaseType;
}
请注意,如果您正在寻找接口,这将不起作用！
c# – 确定对象是否是任何类型的数组,并访问数组长度
public override bool IsValid(object value)
{
Type type = value.GetType();
if (type.IsArray)
{
return ((object[]) value).Length > 0;
}
else
{
return false;
}
}
问题是如果value是int [],当我尝试转换为object []时它会出错.有没有办法处理这个演员,所以它适用于任何类型的数组？
解决方法
return ((Array) value).Length > 0
通过使用as运算符,您可以进一步简化代码：
public static bool IsValid(object value)
{
Array array = value as Array;
return array != null && array.Length > 0;
}
注意：对于多维数组,例如new int [10,10],这将返回true.如果要在这种情况下返回false,请添加对array.Rank == 1的检查.
java – 反射性地检查对象是否是方法的有效泛型参数
为了获得一些背景知识,这就是我想要实现的目标：
在使用反射方法调用时,我认为调用具有特定类型参数的所有方法会很好.这适用于原始类型,因为您可以在其类对象上调用isAssignableFrom(Class<？> c).然而,当你开始在混合中投入泛型时,它突然变得不那么容易,因为泛型不是反射原始设计的一部分,也不是因为类型擦除.
问题更大但它基本归结为以下几点：
理想解决方案
理想情况下代码
import java.lang.reflect.*;
import java.util.*;
public class ReflectionAbuse {
public static void callMeMaybe(List<Integer> number) {
System.out.println("You called me!");
}
public static void callMeAgain(List<? extends Number> number) {
System.out.println("You called me again!");
}
public static void callMeNot(List<Double> number) {
System.out.println("What's wrong with you?");
}
public static <T> void reflectiveCall(List<T> number){
for(Method method : ReflectionAbuse.class.getDeclaredMethods()) {
if(method.getName().startsWith("call")) {
if(canBeParameterOf(method,number)) {
try {
method.invoke(null,number);
} catch (Exception e) {
e.printstacktrace();
}
}
}
}
}
public static <T> boolean canBeParameterOf(Method method,List<T> number) {
// FIXME some checks missing
return true;
}
public static void main(String[] args) {
reflectiveCall(new ArrayList<Integer>());
}
}
会打印
You called me! You called me again!
无论T看起来如何(即它可能是另一个通用类型,例如List< List< Integer>>),这应该是可能的.
显然这不起作用,因为类型T在运行时被擦除和未知.
尝试1
我能做的第一件事是这样的：
import java.lang.reflect.*;
import java.util.*;
public class ReflectionAbuse {
public static void callMeMaybe(ArrayList<Integer> number) {
System.out.println("You called me!");
}
public static void callMeAgain(ArrayList<? extends Number> number) {
System.out.println("You called me again!");
}
public static void callMeNot(ArrayList<Double> number) {
System.out.println("What's wrong with you?");
}
public static <T> void reflectiveCall(List<T> number){
for(Method method : ReflectionAbuse.class.getDeclaredMethods()) {
if(method.getName().startsWith("call")) {
if(canBeParameterOf(method,List<T> number) {
return method.getGenericParameterTypes()[0].equals(number.getClass().getGenericSuperclass());
}
public static void main(String[] args) {
reflectiveCall(new ArrayList<Integer>(){});
}
}
只打印
You called me!
但是,这有一些额外的警告：
>它仅适用于直接实例,并且不考虑继承层次结构,因为Type接口不提供所需的方法.这里和那里的演员肯定有助于找到这一点(另见我的第二次尝试)
> reflectCall的参数实际上需要是有用参数类型的子类(注意新ArrayList< Integer>(){}中的{},它创建一个匿名内部类).这显然不太理想：创建不必要的类对象并且容易出错.这是我能想到绕过类型擦除的唯一方法.
尝试2
考虑到由于擦除而在理想解决方案中缺失类型,人们也可以将该类型作为一个非常接近理想的参数传递：
import java.lang.reflect.*;
import java.util.*;
public class ReflectionAbuse {
public static void callMeMaybe(List<Integer> number) {
System.out.println("You called me!");
}
public static void callMeAgain(List<? extends Number> number) {
System.out.println("You called me again!");
}
public static void callMeNot(List<Double> number) {
System.out.println("What's wrong with you?");
}
public static <T> void reflectiveCall(List<T> number,Class<T> clazz){
for(Method method : ReflectionAbuse.class.getDeclaredMethods()) {
if(method.getName().startsWith("call")) {
Type n = number.getClass().getGenericSuperclass();
if(canBeParameterOf(method,clazz)) {
try {
method.invoke(null,Class<T> clazz) {
Type type = ((ParameterizedType)method.getGenericParameterTypes()[0]).getActualTypeArguments()[0];
if (type instanceof WildcardType) {
return ((Class<?>)(((WildcardType) type).getUpperBounds()[0])).isAssignableFrom(clazz);
}
return ((Class<?>)type).isAssignableFrom(clazz);
}
public static void main(String[] args) {
reflectiveCall(new ArrayList<Integer>(),Integer.class);
}
}
实际上打印正确的解决方案.但这也不是没有消极方面：
> reflectCall的用户需要传递类型参数,这是不必要和繁琐的.至少在编译时检查正确的调用.
>类型参数之间的继承没有被完全考虑在内,肯定还有许多需要在canBeParameterOf中实现的情况(例如类型参数).
>最大的问题：类型参数本身不能是通用的,因此不能将整数列表列表用作参数.
这个问题
有什么我可以做的不同,以尽可能接近我的目标？我是坚持使用匿名子类还是传递类型参数？目前,我将决定给出参数,因为这样可以节省编译时间.
在递归检查参数类型时,我需要注意什么？
是否有可能允许泛型在解决方案2中使用类型参数？
实际上,出于学习目的,我想推出自己的解决方案而不是使用库,尽管我不介意看一些内部工作.
为了清楚起见,我举例说明了以下内容,但尝试保持示例清洁：
>这可以在没有反射的情况下解决(同时重新设计一些要求并使用例如接口和内部类).这是出于学习目的.我想要解决的问题实际上要大得多,但这就是它归结为什么.
>我可以使用注释,而不是使用命名模式.我实际上是这样做的,但我想让这些例子尽可能保持独立.
> getGenericParameterTypes()返回的数组可能为空,但我们假设所有方法都有一个参数,并事先检查过.
>调用null时,可能存在失效的非静态方法.假设没有.
>捕捞条件可能更具体.
>有些演员需要更安全.
解决方法
Am I stuck with either using anonymous subclasses or passing the type parameter?
或多或少,但更好地使用super type token模式子类而不是子类化您的值类型.毕竟,您的值类型可能不允许子类.使用类型标记模式允许您接受泛型类型,而接受类作为类型参数仅允许原始类型(这就是您必须采用List的组件类型而不是类型本身的原因).
public static <T> void reflectiveCall(Typetoken<T> type,T value)
Guava非常支持创建和使用TypeToken.到目前为止,创建一个最简单的方法是创建一个匿名子类(注意：如果它将被重用,请将其设为常量)：
reflectiveCall(new Typetoken<List<Integer>>() {},new ArrayList<Integer>());
一旦你有了这个,canBeParameterOf变得更容易实现.
public static boolean canBeParameterOf(Method method,Typetoken<?> givenType) {
Type[] argTypes = method.getGenericParameterTypes();
return argTypes.length != 0 &&
Typetoken.of(argTypes[0]).isAssignableFrom(givenType);
}
关于如何确定对象是否是PySpark中的有效键值对和判断对象是否存在某个key的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于c# – 如何确定对象引用是否为空？、c# – 如何确定对象是否继承自抽象泛型类、c# – 确定对象是否是任何类型的数组,并访问数组长度、java – 反射性地检查对象是否是方法的有效泛型参数的相关信息，请在本站寻找。
本文标签：
