दिलचस्प पोस्ट
एंड्रॉइड में पुनरावृत्त गतिशील जेएसएन स्ट्रिंग के माध्यम से लूप करने में असमर्थ कोकोसडीडी संसाधन सर्वर में एचटीएक्ससएएस में PHP संस्करण कैसे बदला जाए वाष्पशील बनाम इंटरलॉक बनाम लॉक फ़ायरफ़ॉक्स समर्थन की स्थिति है: टेबल तत्वों पर रिश्तेदार? PHP में FQL द्वारा लौटते बड़े यूजर आईडी को संभालना 404 हेडर – HTTP 1.0 या 1.1? Google मानचित्र जावास्क्रिप्ट एपीआई v3 मैप लेबल और बहुभुज कैसे एक एनएसटीटीटी के लिए एक क्लिक करने योग्य लिंक बनाने के लिए केवल डिबग बिल्ड के लिए विजुअल स्टूडियो पोस्ट-बिल्ड इवेंट कैसे चलाएं जावा प्रोजेक्ट्स के लिए बिल्ड और वर्जन नंबरिंग (चींटी, सीवीएस, हडसन) Android पर ड्रॉएबल संसाधन से छवि को एसडी कार्ड में सहेजें Chrome में पृष्ठभूमि रंग प्रिंट करें SQLite के साथ सी # पैरामीटर जोड़ना बाश में किसी फ़ाइल की अंतिम संशोधित तारीख को प्रिंट करें

जावा की छुपी हुई विशेषताएं

सी # की छिपी हुई विशेषताओं को पढ़ने के बाद मुझे आश्चर्य है, जावा की छिपी सुविधाओं में से कुछ क्या हैं?

Solutions Collecting From Web of "जावा की छुपी हुई विशेषताएं"

डबल ब्रेस इन्लीनाइजेशन मुझे कुछ महीने पहले आश्चर्य हुआ था जब मैंने इसे पहली बार खोजा था, इससे पहले कभी नहीं सुना।

थ्रेडलोकल्स आम तौर पर प्रति-थ्रेड स्थिति को संग्रहीत करने के तरीके के रूप में इतने व्यापक रूप से ज्ञात नहीं हैं।

चूंकि जेडीके 1.5 जावा बहुत अच्छी तरह से लागू किया गया है और मजबूत संगामिति उपकरण सिर्फ तालों से परे है, वे java.util.concurrent में रहते हैं और एक विशेष रूप से दिलचस्प उदाहरण java.util.concurrent.atomic सबपैकेज है जिसमें धागे-सुरक्षित primitives जो कि तुलना करते हैं -और-स्वैप कार्रवाई और इन कार्यों के वास्तविक नेटवर्क्स-समर्थित संस्करणों में मैप कर सकते हैं।

संयुक्त पैरामीटर प्रकार पैरामीटर प्रकार में:

public class Baz<T extends Foo & Bar> {} 

उदाहरण के लिए, यदि आप एक पैरामीटर लेना चाहते हैं जो कि तुलनात्मक और संग्रह दोनों है:

 public static <A, B extends Collection<A> & Comparable<B>> boolean foo(B b1, B b2, A a) { return (b1.compareTo(b2) == 0) || b1.contains(a) || b2.contains(a); } 

यदि ये दो दिए गए संकलन बराबर हैं या यदि इनमें से कोई एक में दिया तत्व है, अन्यथा गलत ध्यान देने की बात यह है कि आप तर्कसंगत बी 1 और बी 2 पर तुलनात्मक और संग्रह दोनों तरीकों को लागू कर सकते हैं।

मैं उदाहरण के शुरुआती दिनों से आश्चर्यचकित था मैं कुछ कोड-जोड़ तरीके को हटा रहा था और कई उदाहरण initializers बनाने समाप्त हो गया था:

 public class App { public App(String name) { System.out.println(name + "'s constructor called"); } static { System.out.println("static initializer called"); } { System.out.println("instance initializer called"); } static { System.out.println("static initializer2 called"); } { System.out.println("instance initializer2 called"); } public static void main( String[] args ) { new App("one"); new App("two"); } } 

main विधि निष्पादित करेगा:

 static initializer called static initializer2 called instance initializer called instance initializer2 called one's constructor called instance initializer called instance initializer2 called two's constructor called 

मुझे लगता है ये उपयोगी होगा यदि आपके पास कई कंस्ट्रक्टर होंगे और सामान्य कोड की आवश्यकता होगी

वे अपनी कक्षाओं को आरंभ करने के लिए वाक्यविन्यास चीनी भी प्रदान करते हैं:

 List<Integer> numbers = new ArrayList<Integer>(){{ add(1); add(2); }}; Map<String,String> codes = new HashMap<String,String>(){{ put("1","one"); put("2","two"); }}; 

JDK 1.6_07 + में VisualVM (bin / jvisualvm.exe) नामक ऐप शामिल है जो कई उपकरणों के शीर्ष पर एक अच्छा जीयूआई है यह JConsole से अधिक व्यापक लगता है

जावा 6 के बाद से कक्षापाथ वाइल्ड कार्ड

 java -classpath ./lib/* so.Main 

के बजाय

 java -classpath ./lib/log4j.jar:./lib/commons-codec.jar:./lib/commons-httpclient.jar:./lib/commons-collections.jar:./lib/myApp.jar so.Main 

http://java.sun.com/javase/6/docs/technotes/tools/windows/classpath.html देखें

ज्यादातर लोगों के लिए मैं जावा डेवलपर ब्लॉकों लेबल पदों के लिए साक्षात्कार बहुत आश्चर्य की बात है। यहाँ एक उदाहरण है:

 // code goes here getmeout:{ for (int i = 0; i < N; ++i) { for (int j = i; j < N; ++j) { for (int k = j; k < N; ++k) { //do something here break getmeout; } } } } 

किसने कहा जावा में goto सिर्फ एक कीवर्ड है? 🙂

किस प्रकार के लौकिक प्रकार के बारे में जेडीके 1.5 के बाद से किया गया है? यह काफी खराब प्रचारित है, क्योंकि यह एक अप्रभावी जोड़ है, लेकिन जैसा कि मैं समझता हूं, जेनेरिक काम करने के लिए बिल्कुल जरूरी है।

मूल रूप से, कंपाइलर अब एक उपवर्ग को मूल पद्धति के रिटर्न प्रकार के उपवर्ग होने के लिए ओवरराइड पद्धति के रिटर्न प्रकार को संकीर्ण करने की अनुमति देता है। तो यह अनुमति है:

 class Souper { Collection<String> values() { ... } } class ThreadSafeSortedSub extends Souper { @Override ConcurrentSkipListSet<String> values() { ... } } 

आप उप-वर्ग की values विधि को कॉल कर सकते हैं और एक सॉर्ट किए गए थ्रेड सुरक्षित Set String Set को बिना ConcurrentSkipListSet डाल सकते हैं

किसी व्यक्ति को इस तरह से लागू होने का उल्लेख नहीं किया गया है जो कि अशक्त की जांच करना आवश्यक नहीं है।

के बजाय:

 if( null != aObject && aObject instanceof String ) { ... } 

महज प्रयोग करें:

 if( aObject instanceof String ) { ... } 

अंत में ब्लॉक में नियंत्रण हस्तांतरण किसी भी अपवाद फेंकता है। निम्नलिखित कोड RuntimeException फेंक नहीं करता – यह खो जाता है।

 public static void doSomething() { try { //Normally you would have code that doesn't explicitly appear //to throw exceptions so it would be harder to see the problem. throw new RuntimeException(); } finally { return; } } 

से http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

विधियों और कन्स्ट्रक्टरों को enums में अनुमति दे मुझे आश्चर्य है उदाहरण के लिए:

 enum Cats { FELIX(2), SHEEBA(3), RUFUS(7); private int mAge; Cats(int age) { mAge = age; } public int getAge() { return mAge; } } 

आपके पास "निरंतर विशिष्ट वर्ग निकाय" भी हो सकता है जो एक विशिष्ट मान मान को ओवरराइड विधियों के लिए अनुमति देता है।

यहां अधिक दस्तावेज।

जेनेरिक तरीकों के लिए प्रकार पैराम्स स्पष्ट रूप से निर्दिष्ट किया जा सकता है:

 Collections.<String,Integer>emptyMap() 

आप एक इंटरफेस लागू करने के लिए enums का उपयोग कर सकते हैं।

 public interface Room { public Room north(); public Room south(); public Room east(); public Room west(); } public enum Rooms implements Room { FIRST { public Room north() { return SECOND; } }, SECOND { public Room south() { return FIRST; } } public Room north() { return null; } public Room south() { return null; } public Room east() { return null; } public Room west() { return null; } } 

संपादित करें: वर्षों बाद ….

मैं यहां इस सुविधा का उपयोग करता हूं

 public enum AffinityStrategies implements AffinityStrategy { 

https://github.com/peter-lawrey/Java-Thread-Affinity/blob/master/src/main/java/vanilla/java/affinity/AffinityStrategies.java

एक इंटरफ़ेस का उपयोग करके डेवलपर्स अपनी रणनीतियों को परिभाषित कर सकते हैं। enum का उपयोग करने का अर्थ है कि मैं उन लोगों में संग्रहित (संग्रहित) संग्रह परिभाषित कर सकता हूं।

जावा 1.5 के रूप में, जावा में अब चर आकांक्षा के कार्यों को लिखने के लिए बहुत क्लीनर सिंटेक्स है। इसलिए, सिर्फ एक सरणी गुजारने के बजाय, अब आप निम्न कर सकते हैं

 public void foo(String... bars) { for (String bar: bars) System.out.println(bar); } 

सलाखों को स्वचालित रूप से निर्दिष्ट प्रकार की सरणी में परिवर्तित कर दिया जाता है। एक बड़ी जीत नहीं है, लेकिन फिर भी एक जीत।

मेरा पसंदीदा: सभी धागा स्टैक निशान मानक बाहर करने के लिए डंप।

खिड़कियां: सीटीआरएल – अपने जावा सीएमडी / कंसोल विंडो में तोड़ो

यूनिक्स: kill -3 PID

कुछ लोगों ने उदाहरण प्रारंभकर्ताओं के बारे में पोस्ट किया है, यहां इसका एक अच्छा उपयोग है:

 Map map = new HashMap() {{ put("a key", "a value"); put("another key", "another value"); }}; 

यदि आप बस कुछ सरल और सरल कर रहे हैं, तो नक्शे को इनिशियलाइज़ करने का एक त्वरित तरीका है

या त्वरित स्विंग फ़्रेम प्रोटोटाइप बनाने के लिए इसका इस्तेमाल कर रहे हैं:

 JFrame frame = new JFrame(); JPanel panel = new JPanel(); panel.add( new JLabel("Hey there"){{ setBackground(Color.black); setForeground( Color.white); }}); panel.add( new JButton("Ok"){{ addActionListener( new ActionListener(){ public void actionPerformed( ActionEvent ae ){ System.out.println("Button pushed"); } }); }}); frame.add( panel ); 

बेशक यह दुरुपयोग किया जा सकता है:

  JFrame frame = new JFrame(){{ add( new JPanel(){{ add( new JLabel("Hey there"){{ setBackground(Color.black); setForeground( Color.white); }}); add( new JButton("Ok"){{ addActionListener( new ActionListener(){ public void actionPerformed( ActionEvent ae ){ System.out.println("Button pushed"); } }); }}); }}); }}; 

डायनामिक प्रॉक्सी (1.3 में जोड़े गए) आपको रनटाइम पर एक नए प्रकार को परिभाषित करने की अनुमति मिलती है जो इंटरफ़ेस के अनुरूप है। यह समय की एक आश्चर्यजनक संख्या में काम आता है

अंतिम इनिशियलाइजेशन को स्थगित किया जा सकता है

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

 public Object getElementAt(int index) { final Object element; if (index == 0) { element = "Result 1"; } else if (index == 1) { element = "Result 2"; } else { element = "Result 3"; } return element; } 

मुझे लगता है कि जावा की एक और "अनदेखी" सुविधा जेवीएम ही है यह शायद सबसे अच्छा वीएम उपलब्ध है और यह कई रोचक और उपयोगी भाषाओं का समर्थन करता है (जेथोन, जेरुबी, स्काला, ग्रूवी)। उन सभी भाषाओं को सहज और सहज रूप से सहयोग कर सकते हैं

यदि आप एक नई भाषा तैयार करते हैं (जैसे स्काले-केस में) आप तुरंत सभी मौजूदा पुस्तकालय उपलब्ध कराते हैं और आपकी भाषा बहुत शुरुआत से "उपयोगी" है

उन सभी भाषाओं में हॉटस्पॉट अनुकूलन का इस्तेमाल होता है वीएम बहुत अच्छी तरह से मॉनिटर और डिबग करने योग्य है।

आप एक गुमनाम उपवर्ग को परिभाषित कर सकते हैं और इस पर एक विधि को सीधे कॉल कर सकते हैं भले ही यह कोई इंटरफेस लागू न करे।

 new Object() { void foo(String s) { System.out.println(s); } }.foo("Hello"); 

Java.util.Arrays में asList विधि varargs, सामान्य तरीकों और autoboxing का एक अच्छा संयोजन की अनुमति देता है:

 List<Integer> ints = Arrays.asList(1,2,3); 

इस कीवर्ड का उपयोग करके एक आंतरिक कक्षा से वर्ग वाले विधियों / विधियों तक पहुंचने के लिए। नीचे दिए गए उदाहरण के बजाय, हम अज्ञात आंतरिक कक्षा से कंटेनर वर्ग के क्रमबद्ध आरोपण क्षेत्र का उपयोग करना चाहते हैं। कंटेनर क्लास का उपयोग करना। इस स्रोत की बजाय बढ़ते क्रम में चलना चाल है।

 import java.util.Comparator; public class ContainerClass { boolean sortAscending; public Comparator createComparator(final boolean sortAscending){ Comparator comparator = new Comparator<Integer>() { public int compare(Integer o1, Integer o2) { if (sortAscending || ContainerClass.this.sortAscending) { return o1 - o2; } else { return o2 - o1; } } }; return comparator; } } 

वास्तव में एक सुविधा नहीं है, लेकिन एक मनोरंजक चाल मैंने हाल ही में कुछ वेब पेज में खोजी:

 class Example { public static void main(String[] args) { System.out.println("Hello World!"); http://Phi.Lho.free.fr System.exit(0); } } 

एक वैध जावा प्रोग्राम है (हालांकि यह एक चेतावनी उत्पन्न करता है)। यदि आप नहीं देखते हैं, तो ग्रेगरी का जवाब देखें! 😉 अच्छी तरह से, यहां हाइलाइट सिंटैक्स भी एक संकेत देता है!

यह बिल्कुल "छिपी हुई विशेषताओं" नहीं है और बहुत उपयोगी नहीं है, लेकिन कुछ मामलों में यह बेहद रोचक हो सकती है:
क्लास सोर। मिस। यूनिफ़े – आप जावा में प्रत्यक्ष मेमोरी प्रबंधन को कार्यान्वित करने की अनुमति देगा (यदि आप बहुत कोशिश करते हैं तो आप इसके साथ जावा कोड स्वयं को संशोधित कर सकते हैं):

 public class UnsafeUtil { public static Unsafe unsafe; private static long fieldOffset; private static UnsafeUtil instance = new UnsafeUtil(); private Object obj; static { try { Field f = Unsafe.class.getDeclaredField("theUnsafe"); f.setAccessible(true); unsafe = (Unsafe)f.get(null); fieldOffset = unsafe.objectFieldOffset(UnsafeUtil.class.getDeclaredField("obj")); } catch (Exception e) { throw new RuntimeException(e); } }; } 

स्विंग में काम करते समय मुझे छिपे हुए CtrlShiftF1 सुविधा पसंद है I

यह वर्तमान विंडो के घटक वृक्ष को ढंक कर देता है।
(मान लें कि आपने कुछ और कीस्ट्रोक को बाध्य नहीं किया है।)

हर क्लास फ़ाइल हेक्स वैल्यू 0xCAFEBABE के साथ शुरू होती है जो इसे मान्य जेवीएम बायटेक के रूप में पहचानती है।

( स्पष्टीकरण )

मेरा वोट java.util.Concurrent के साथ जाता है इसके समवर्ती संग्रह और लचीला निष्पादक के साथ अन्य धागा पूल, अनुसूचित कार्यों और समन्वित कार्यों के बीच की अनुमति। DelayQueue मेरा व्यक्तिगत पसंदीदा है, जहां तत्व निर्दिष्ट देरी के बाद उपलब्ध कराए जाते हैं।

java.util.Timer और TimerTask सुरक्षित रूप से आराम करने के लिए रखा जा सकता है।

इसके अलावा, पूरी तरह से छिपा नहीं बल्कि दिनांक और समय से संबंधित अन्य वर्गों से अलग पैकेज में। java.util.concurrent.TimeUnit उपयोगी है जब नैनोसेकंड्स, माइक्रोसॉन्ड्स, मिलीसेकंड्स और सेकंड के बीच परिवर्तित होता है।

यह कुछ सामान्य मूल्य * 1000 या कुछ वैल्यू / 1000 के मुकाबले बहुत बेहतर पढ़ता है।

भाषा स्तर के कीवर्ड पर जोर डालें

वास्तव में जावा भाषा का हिस्सा नहीं है, लेकिन जवाज डिस्साइम्बलर जो सूर्य के जेडीके के साथ आता है, वह व्यापक रूप से ज्ञात नहीं है या इसका उपयोग नहीं किया जाता है।

प्रत्येक लूप 1.5 के लिए निर्माण के अलावा मैं <3 इसे

 // For each Object, instantiated as foo, in myCollection for(Object foo: myCollection) { System.out.println(foo.toString()); } 

और नेस्टेड उदाहरणों में इस्तेमाल किया जा सकता है:

 for (Suit suit : suits) for (Rank rank : ranks) sortedDeck.add(new Card(suit, rank)); 

प्रत्येक निर्माण के लिए एरे के लिए भी लागू होता है, जहां यह इरेरेटर की बजाय सूचकांक चर को छुपाता है। निम्न पद्धति किसी int सरणी में मानों का योग देता है:

 // Returns the sum of the elements of a int sum(int[] a) { int result = 0; for (int i : a) result += i; return result; } 

सूर्य के दस्तावेज़ से लिंक करें

i personally discovered java.lang.Void very late — improves code readability in conjunction with generics, eg Callable<Void>