क्या जावा में C # Ref और out कीवर्ड जैसे कुछ हैं?

Question

कुछ इस तरह है:

रेफरी उदाहरण:

void changeString(ref String str) {
    str = "def";
}

void main() {
    String abc = "abc";
    changeString(ref abc);
    System.out.println(abc); //prints "def"
}

बाहर का उदाहरण:

void changeString(out String str) {
    str = "def";
}

void main() {
    String abc;
    changeString(out abc);
    System.out.println(abc); //prints "def"
}

Comments

के संभावित डुप्लिकेट जावा में संदर्भ द्वारा Can मैं पास मानकों?

— रॉबर्ट हार्वे

IMO आप बहुत याद नहीं कर रहे हैं। केवल समय मैं कभी भी उपयोग करते हैं refया outसी # में जब मैं की तरह एक पैटर्न का उपयोग कर रहा है TryParse(), जहां विधि एक बूलियन परिणाम देता है, और एक ही तरीका है इसे से बाहर एक पार्स मूल्य प्राप्त करने का उपयोग करना है refया out।

— रॉबर्ट हार्वे

लगता है क्या, यह सही है जो मुझे उपयोग करने की आवश्यकता है! ;)

— 10:10

इसे करने का दूसरा तरीका स्थिति और अशक्त मूल्य दोनों के साथ एक समग्र वस्तु को वापस करना है। लेकिन मैं मानता हूं कि थोड़ा रब गोल्डबर्ग-ईश है।

— रॉबर्ट हार्वे

समग्र वस्तु लौटाने में कुछ भी गलत नहीं है, अगर केवल एक पूर्वनिर्धारित प्रयोग करने योग्य (यानी टुपल्स) होगा। लेकिन रुको, कि आदिम प्रकार के साथ काम करने के लिए गैर-मिटे हुए जेनेरिक को कुशल होने की आवश्यकता होगी :)

— पावेल मिनावे

Answer 1

नहीं, जावा में संदर्भ से गुजरने के लिए C # refऔर outकीवर्ड जैसी कोई चीज़ नहीं है ।

आप केवल जावा में मान से पास कर सकते हैं। यहां तक ​​कि संदर्भ भी मूल्य द्वारा पारित किए जाते हैं। देखें जॉन स्कीट के बारे में पेज पैरामीटर जावा में गुजर अधिक जानकारी के लिए।

इसके समान कुछ करने के लिए refया outआपको अपने पैरामीटर को किसी अन्य ऑब्जेक्ट के अंदर लपेटना होगा और उस ऑब्जेक्ट संदर्भ को एक पैरामीटर के रूप में पास करना होगा।

Comments

इसका विस्तार कुछ पर किया जाना चाहिए। आप मूल्य के रूप में केवल आदिम (इंट, लघु, चार, आदि) पास कर सकते हैं। और नहीं, कोई बाहर नहीं है।

— कोरी सनवॉल्ड

यह 100% सत्य नहीं है, यदि आप किसी ऐरे या वर्ग में पास होते हैं, तो एरे या ऑब्जेक्ट के संदर्भ को वैल्यू द्वारा पास किया जाता है, आप इंटर्न को एरे या ऑब्जेक्ट में बदल सकते हैं और यह कॉलर में परिलक्षित होगा।

— रोमेन हिप्पो

@fearofawhackplanet: उम, जब तक आप उपयोग नहीं करते ref।

— रॉबर्ट हार्वे

@fearofawhackplanet: Reference parameters need the ref modifier as part of both the declaration and the invocation - that means it's always clear when you're passing something by reference. yoda.arachsys.com/csharp/parameters.html

— मार्क बायर्स

सीएलआर के नजरिए से, आप एक प्रबंधित संदर्भ ( T&) मान से गुजर रहे हैं , हां। लेकिन C # की अपनी शब्दावली है, और यह विशेष रूप से ऐसी चीजों को प्रकार के मूल्यों में शामिल नहीं करता है ref T- C # परिप्रेक्ष्य से, refकड़ाई से एक पैरामीटर संशोधक है, और इसके संदर्भ में "मूल्य से एक संदर्भ पारित करना" बोलना मायने नहीं रखता है। ।

— पावेल मिनाएव

Answer 2

सीधा जवाब: नहीं

लेकिन आप रैपर के साथ संदर्भ का अनुकरण कर सकते हैं ।

और निम्न कार्य करें:

void changeString( _<String> str ) {
    str.s("def");
}

void testRef() {
     _<String> abc = new _<String>("abc");
     changeString( abc );
     out.println( abc ); // prints def
}

बाहर

void setString( _<String> ref ) {
    str.s( "def" );
}
void testOut(){
    _<String> abc = _<String>();
    setString( abc );
    out.println(abc); // prints def
}

और मूल रूप से कोई अन्य प्रकार जैसे:

_<Integer> one = new <Integer>(1);
addOneTo( one );

out.println( one ); // May print 2

Comments

आउच। वह बदसूरत है।

— ईलायची खा लिया

मैंने कभी नहीं कहा, आप इसे इस सुरुचिपूर्ण तरीके से कर सकते हैं : पी

— ऑस्कररिज़

तो निम्न काम क्यों नहीं करता है: निजी स्थिर शून्य पार्सलीन (स्ट्रिंग न्यूलाइन, स्ट्रिंग [] aWrapper, Integer [] bWrapper) {StringTokenizer st = new StringTokenizer (newline); aWrapper [0] = st.nextToken (); bWrapper [0] = new Integer (st.nextToken ()); } ParseLine (newline, new String [] {a}, नया Integer [] {b});

— एलाड बेंडा

@ user311130 आपका कोड पढ़ना कठिन है, लेकिन आप कुछ नया प्रश्न बना सकते हैं, जैसे कुछ: "मुझे यह उत्तर मिला <<मेरे उत्तर के लिए लिंक> लेकिन निम्नलिखित काम नहीं करता है <आपका कोड यहाँ>

— OscarRyz

यह बुरा है, लेकिन मैं अभी भी इसे एक तरह से दे रहा हूं क्योंकि यह समस्या को "सबसे साफ" तरीके से हल करता है जो मैं इस समय में जावा के लिए सोच सकता हूं ...

— पंगम्मा

Answer 3

असल में वहाँ न तो है रेफरी और न ही बाहर में कीवर्ड बराबर जावा भाषा के रूप में तक मुझे पता है। हालाँकि मैंने अभी जावा में C # कोड को बदल दिया है जो पैरामीटर का उपयोग करता है और सलाह देगा कि मैंने अभी क्या किया है। आपको रैपर क्लास में किसी भी वस्तु को लपेटना चाहिए और निम्न प्रकार के रैपर ऑब्जेक्ट में लिपटे हुए मूल्यों को पास करना चाहिए;

रैपर का उपयोग करने के लिए एक सरल उदाहरण

यहाँ रैपर्स क्लास है ;

public class Wrapper {
    public Object ref1; // use this as ref
    public Object ref2; // use this as out

    public Wrapper(Object ref1) {
        this.ref1 = ref1;
    }
}

और यहाँ परीक्षण कोड है;

public class Test {

    public static void main(String[] args) {
        String abc = "abc";
        changeString(abc);
        System.out.println("Initial object: " + abc); //wont print "def"

        Wrapper w = new Wrapper(abc);
        changeStringWithWrapper(w);
        System.out.println("Updated object: " + w.ref1);
        System.out.println("Out     object: " + w.ref2);
    }

    // This won't work
    public static void changeString(String str) {
        str = "def";
    }

    // This will work
    public static void changeStringWithWrapper(Wrapper w) {
        w.ref1 = "def";
        w.ref2 = "And this should be used as out!";
    }

}

एक वास्तविक विश्व उदाहरण

पैरामीटर का उपयोग करके एसी # .NET विधि

यहाँ एक C # .NET विधि है जो कीवर्ड का उपयोग कर रही है ;

public bool Contains(T value)
{
    BinaryTreeNode<T> parent;
    return FindWithParent(value, out parent) != null;
}

private BinaryTreeNode<T> FindWithParent(T value, out BinaryTreeNode<T> parent)
{
    BinaryTreeNode<T> current = _head;
    parent = null;

    while(current != null)
    {
        int result = current.CompareTo(value);

        if (result > 0)
        {
            parent = current;
            current = current.Left;
        }
        else if (result < 0)
        {
            parent = current;
            current = current.Right;
        }
        else
        {
            break;
        }
    }

    return current;
}

जावा सी # कोड के समकक्ष जो बाहर पैरामीटर का उपयोग कर रहा है

और रैपर क्लास की मदद से इस विधि के बराबर जावा निम्नानुसार है;

public boolean contains(T value) {
    BinaryTreeNodeGeneration<T> result = findWithParent(value);

    return (result != null);
}

private BinaryTreeNodeGeneration<T> findWithParent(T value) {
    BinaryTreeNode<T> current = head;
    BinaryTreeNode<T> parent = null;
    BinaryTreeNodeGeneration<T> resultGeneration = new BinaryTreeNodeGeneration<T>();
    resultGeneration.setParentNode(null);

    while(current != null) {
        int result = current.compareTo(value);

        if(result >0) {
            parent = current;
            current = current.left;
        } else if(result < 0) {
            parent = current;
            current = current.right;
        } else {
            break;
        }
    }

    resultGeneration.setChildNode(current);
    resultGeneration.setParentNode(parent);

    return resultGeneration;
}

रैपर क्लास

और इस जावा कोड में प्रयुक्त रैपर क्लास नीचे है;

public class BinaryTreeNodeGeneration<TNode extends Comparable<TNode>>  {

    private BinaryTreeNode<TNode>   parentNode;
    private BinaryTreeNode<TNode>   childNode;

    public BinaryTreeNodeGeneration() {
        this.parentNode = null;
        this.childNode = null;
    }

    public BinaryTreeNode<TNode> getParentNode() {
        return parentNode;
    }

    public void setParentNode(BinaryTreeNode<TNode> parentNode) {
        this.parentNode = parentNode;
    }

    public BinaryTreeNode<TNode> getChildNode() {
        return childNode;
    }

    public void setChildNode(BinaryTreeNode<TNode> childNode) {
        this.childNode = childNode;
    }

}

Comments

पूर्व के उत्तर देखें।

— पश्त्यूट

एक विस्तृत जवाब एक नकारात्मक वोट देना मज़ेदार है। मैंने एसओ की जाँच की है और डेमो कोड के साथ एक सटीक सटीक उत्तर नहीं पा सका है, इसीलिए मैंने यह उत्तर लिखा है जहाँ तक मुझे याद है। यदि आप किसी एक उत्तर की प्रतीक्षा करते हैं और प्रत्येक दूसरे उत्तर को वोट करते हैं, तो एसओ को उस प्रश्न के स्वामी से पुष्टि के अलावा अन्य सभी उत्तर पर प्रतिबंध लगाना चाहिए।

— लेवेंट डिविलीग्लू सेप

ठीक है, मैं नकारात्मक वोट तभी निकाल सकता हूं जब आप उत्तर को संपादित करेंगे। इसलिए अन्य उत्तरों को पढ़ें और समझाएं कि आप उन समाधानों का उपयोग क्यों नहीं करना चाहते हैं। एक आवरण (और विशेष रूप से एक REF और OUT आवरण केवल इसके मज़े के लिए)। 5 लोगों ने उदाहरणों के साथ छोटे और पूर्ण उत्तर दिए , और केवल ईयाल ने मूल रूप से लिखा: "नो यू कैन"।

— पशूट

यह उत्तर ठीक लग रहा है। यह शीर्ष उत्तर के समान है, लेकिन जावा में रैपर क्लास का उपयोग कैसे करें, इस पर पूरी तरह से विस्तृत उदाहरण देता है।

— हबेटिश

Answer 4

जावा मान से पैरामीटर गुजरता है और पास-पास-संदर्भ की अनुमति देने के लिए कोई तंत्र नहीं है। इसका मतलब है कि जब भी कोई पैरामीटर पास होता है, तो कॉल को संभालने वाले स्टैक फ्रेम में इसका मूल्य कॉपी किया जाता है।

जैसा कि मैं यहां उपयोग करता हूं, शब्द का मूल्य थोड़ा स्पष्टीकरण की आवश्यकता है। जावा में हमारे पास दो प्रकार के चर हैं - आदिम और वस्तुएं। एक आदिम का एक मूल्य ही आदिम है, और एक वस्तु का मूल्य इसका संदर्भ है (और संदर्भित वस्तु की स्थिति नहीं है)। इसलिए, विधि के अंदर मूल्य में कोई भी परिवर्तन केवल स्टैक में मूल्य की प्रतिलिपि को बदल देगा, और कॉलर द्वारा नहीं देखा जाएगा। उदाहरण के लिए, वास्तविक स्वैप विधि को लागू करने का कोई तरीका नहीं है, जो दो संदर्भ प्राप्त करता है और उन्हें स्वैप करता है (उनकी सामग्री नहीं)।

Answer 5

कई अन्य लोगों की तरह, मुझे C # प्रोजेक्ट को Java में बदलने की आवश्यकता थी। मैं के बारे में वेब पर एक पूर्ण समाधान नहीं मिला बाहर और रेफरी संशोधक। लेकिन, मुझे मिली जानकारी को लेने में सक्षम था, और आवश्यकताओं को पूरा करने के लिए अपनी कक्षाएं बनाने के लिए इस पर विस्तार किया। मैं कोड स्पष्टता के लिए रेफरी और आउट मापदंडों के बीच अंतर करना चाहता था । नीचे की कक्षाओं के साथ, यह संभव है। यह जानकारी दूसरों के समय और प्रयास को बचा सकती है।

एक उदाहरण नीचे दिए गए कोड में शामिल है।

//*******************************************************************************************
//XOUT CLASS
//*******************************************************************************************
public class XOUT<T>
{
    public XOBJ<T> Obj = null;

    public XOUT(T value)
    {
        Obj = new XOBJ<T>(value);
    }

    public XOUT()
    {
      Obj = new XOBJ<T>();
    }

    public XOUT<T> Out()
    {
        return(this);
    }

    public XREF<T> Ref()
    {
        return(Obj.Ref());
    }
};

//*******************************************************************************************
//XREF CLASS
//*******************************************************************************************

public class XREF<T>
{
    public XOBJ<T> Obj = null;

    public XREF(T value)
    {
        Obj = new XOBJ<T>(value);
    }

    public XREF()
    {
      Obj = new XOBJ<T>();
    }

    public XOUT<T> Out()
    {
        return(Obj.Out());
    }

    public XREF<T> Ref()
    {
        return(this);
    }
};

//*******************************************************************************************
//XOBJ CLASS
//*******************************************************************************************
/**
 *
 * @author jsimms
 */
/*
    XOBJ is the base object that houses the value. XREF and XOUT are classes that
    internally use XOBJ. The classes XOBJ, XREF, and XOUT have methods that allow
    the object to be used as XREF or XOUT parameter; This is important, because
    objects of these types are interchangeable.

    See Method:
       XXX.Ref()
       XXX.Out()

    The below example shows how to use XOBJ, XREF, and XOUT;
    //
    // Reference parameter example
    //
    void AddToTotal(int a, XREF<Integer> Total)
    {
       Total.Obj.Value += a;
    }

    //
    // out parameter example
    //
    void Add(int a, int b, XOUT<Integer> ParmOut)
    {
       ParmOut.Obj.Value = a+b;
    }

    //
    // XOBJ example
    //
    int XObjTest()
    {
       XOBJ<Integer> Total = new XOBJ<>(0);
       Add(1, 2, Total.Out());    // Example of using out parameter
       AddToTotal(1,Total.Ref()); // Example of using ref parameter
       return(Total.Value);
    }
*/


public class XOBJ<T> {

    public T Value;

    public  XOBJ() {

    }

    public XOBJ(T value) {
        this.Value = value;
    }

    //
    // Method: Ref()
    // Purpose: returns a Reference Parameter object using the XOBJ value
    //
    public XREF<T> Ref()
    {
        XREF<T> ref = new XREF<T>();
        ref.Obj = this;
        return(ref);
    }

    //
    // Method: Out()
    // Purpose: returns an Out Parameter Object using the XOBJ value
    //
    public XOUT<T> Out()
    {
        XOUT<T> out = new XOUT<T>();
        out.Obj = this;
        return(out);
    }

    //
    // Method get()
    // Purpose: returns the value
    // Note: Because this is combersome to edit in the code,
    // the Value object has been made public
    //
    public T get() {
        return Value;
    }

    //
    // Method get()
    // Purpose: sets the value
    // Note: Because this is combersome to edit in the code,
    // the Value object has been made public
    //
    public void set(T anotherValue) {
        Value = anotherValue;
    }

    @Override
    public String toString() {
        return Value.toString();
    }

    @Override
    public boolean equals(Object obj) {
        return Value.equals(obj);
    }

    @Override
    public int hashCode() {
        return Value.hashCode();
    }
}

Answer 6

आधिकारिक तौर पर स्पष्ट रूप से उल्लेखित नहीं तीन समाधान:

ArrayList<String> doThings() {
  //
}

void doThings(ArrayList<String> list) {
  //
}

Pair<String, String> doThings() {
  //
}

जोड़ी के लिए, मैं सुझाऊंगा: https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/Pair.html

Answer 7

जावा के पास इसे करने का कोई मानक तरीका नहीं है। अधिकांश स्वैप उस सूची पर किए जाएंगे जो कक्षा में पैक की गई है। लेकिन ऐसा करने का एक अनौपचारिक तरीका है:

package Example;

import java.lang.reflect.Field;
import java.util.logging.Level;
import java.util.logging.Logger;



 public class Test{


private static <T> void SetValue(T obj,T value){
    try {
        Field f = obj.getClass().getDeclaredField("value");
        f.setAccessible(true);
        f.set(obj,value);
        } catch (IllegalAccessException | IllegalArgumentException | 
            NoSuchFieldException | SecurityException ex) {
            Logger.getLogger(CautrucjavaCanBan.class.getName()).log(Level.SEVERE, 
       null, ex);
        }
}
private  static  void permutation(Integer a,Integer b){
    Integer tmp = new Integer(a);
    SetValue(a, b);
    SetValue(b, tmp);
}
 private  static  void permutation(String a,String b){
    char[] tmp = a.toCharArray();
    SetValue(a, b.toCharArray());
    SetValue(b, tmp);
}
public static void main(String[] args) {
    {
        Integer d = 9;
        Integer e = 8;
        HoanVi(d, e);
        System.out.println(d+" "+ e);
    }
    {
        String d = "tai nguyen";
        String e = "Thai nguyen";
        permutation(d, e);
        System.out.println(d+" "+ e);
    }
}

}

Comments

यह आपको एक पैरामीटर के लिए संदर्भ शब्दार्थ नहीं दे रहा है, यह सिर्फ प्रतिबिंब का उपयोग करके किसी ऐसी वस्तु को म्यूट करने के लिए है जिसे अपरिवर्तनीय बनाया गया है, जो एक भयानक विचार है, और अभी भी पैरामीटर के लिए संदर्भ शब्दार्थ प्रदान नहीं करता है।

— सेवित