🦖 🎣 👴🏽 जावा प्रैक्टिकल टास्क - पाठ्यक्रम और अन्य गतिविधियों के लिए 🚑 👨🏿‍🎨 🚬

जावा प्रैक्टिकल टास्क - पाठ्यक्रम और अन्य गतिविधियों के लिए

कुछ परिचयात्मक शब्द

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

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

बेशक, सभी कार्य पहले से ही कहीं दिखाई दिए हैं। हालांकि, यह लेख प्रोग्रामिंग पाठ्यक्रमों के शिक्षकों (जावा के समान भाषाओं के लिए, अधिकांश कार्य करेगा) या निजी तौर पर प्रोग्रामिंग सिखाने वाले लोगों के उद्देश्य से है। इन कार्यों का उपयोग आपकी कक्षाओं में "आउट ऑफ द बॉक्स" किया जा सकता है। जावा सीखने वाले भी उन्हें हल करने की कोशिश कर सकते हैं। लेकिन ऐसे फैसलों के लिए तीसरे पक्ष के सत्यापन और मूल्यांकन की आवश्यकता होती है।

दशकों से हर किसी का उपयोग करने वाले कुछ सरल कार्य, मैं भी इस लेख में शामिल करता हूं। शायद, अमूर्त वर्गों के साथ तुरंत शुरू न करने के लिए।

किसी भी विचारों और सुझावों का स्वागत है!

कार्य सूची

मूल बातें

1.0। अधिकतम, न्यूनतम और औसत

उद्देश्य:

सरणी को यादृच्छिक संख्याओं से भरें और अधिकतम, न्यूनतम और औसत मूल्य प्रिंट करें।

एक यादृच्छिक संख्या उत्पन्न करने के लिए, Math.random () विधि का उपयोग करें, जो अंतराल में एक मान लौटाता है [0, 1]।

समाधान:

public static void main(String[] args) { int n = 100; double[] array = new double[n]; for (int i = 0; i < array.length; i++) { array[i] = Math.random(); } double max = array[0]; //      double min = array[0]; double avg = 0; for (int i = 0; i < array.length; i++) { if(max < array[i]) max = array[i]; if(min > array[i]) min = array[i]; avg += array[i]/array.length; } System.out.println("max = " + max); System.out.println("min = " + min); System.out.println("avg = " + avg); }

1.1। किसी सरणी को सॉर्ट करने के लिए बबल सॉर्ट एल्गोरिथ्म को लागू करें

समाधान:

  for (int i = 0; i < array.length; i++) { for (int j = 0; j < array.length - i - 1; j++) { if (array[j] > array[j + 1]) { double temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } } for (int i = 0; i < array.length; i++) { System.out.println(array[i]); }

1.2। अभाज्य संख्याओं की खोज करें

उद्देश्य:

एक प्रोग्राम लिखें जो प्राइम नंबर को कंसोल में [2, 100] के बीच प्रिंट करता है।
इस समस्या को हल करने के लिए % ऑपरेटर (विभाजन के शेष) और छोरों का उपयोग करें।

समाधान:

  for(int i = 2; i <= 100; i ++){ boolean isPrime = true; for(int j = 2; j < i; j++){ if(i % j == 0){ isPrime = false; break; } } if(isPrime){ System.out.println(i); } }

या लेबल छोरों का उपयोग करना:

  out_for: for (int i = 2; i <= 100; i++) { for (int j = 2; j < i; j++) { if (i % j == 0) { continue out_for; } } System.out.println(i); }

1.3। सरणी से हटाएं

उद्देश्य:

पूर्णांक के एक सरणी और एक अन्य पूर्णांक को देखते हुए। इस संख्या की सभी आवृत्तियों को सरणी से निकालें (कोई अंतराल नहीं होना चाहिए)।

समाधान:

  public static void main(String[] args) { int test_array[] = {0,1,2,2,3,0,4,2}; /* Arrays.toString: . https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html */ System.out.println(Arrays.toString(removeElement(test_array, 3))); } public static int[] removeElement(int[] nums, int val) { int offset = 0; for(int i = 0; i< nums.length; i++){ if(nums[i] == val){ offset++; } else{ nums[i - offset] = nums[i]; } } // Arrays.copyOf     nums    //   nums.length - offset return Arrays.copyOf(nums, nums.length - offset); }

आप अपने आप को सरणी की पूंछ काटने के लिए एक विधि लिख सकते हैं, लेकिन यह ध्यान देने योग्य है कि मानक विधि तेजी से काम करेगी:

 public static int[] removeElement(int[] nums, int val) { int offset = 0; for(int i = 0; i< nums.length; i++){ if(nums[i] == val){ offset++; } else{ nums[i - offset] = nums[i]; } } int[] newArray = new int[nums.length - offset]; for(int i = 0; i < newArray.length; i++){ newArray[i] = nums[i]; } return newArray; }

हालाँकि, यदि आप इस तरह से जाते हैं, तो आप पहले वांछित लंबाई का एक सरणी बना सकते हैं, और फिर उसे भर सकते हैं:

 public static int[] removeElement(int[] nums, int val) { int count = 0; //      for (int i = 0; i < nums.length; i++) { if (nums[i] != val) { count++; } } int[] newArray = new int[count]; int offset = 0; //      , //       for(int i = 0; i< nums.length; i++){ if(nums[i] == val){ offset++; } else{ newArray[i - offset] = nums[i]; } } return newArray; }

2.0। एक सदिश वर्ग डिजाइन करना और बनाना

उद्देश्य:

एक वर्ग बनाएं जो एक वेक्टर का वर्णन करता है (तीन आयामी स्थान में)।

उसके पास होना चाहिए:

निर्देशांक x, y, z की सूची के रूप में मापदंडों के साथ निर्माता
एक वेक्टर की लंबाई की गणना करने वाली विधि। रूट की गणना Math.sqrt () का उपयोग करके की जा सकती है:
$\ sqrt {x ^ 2 + y ^ 2 + z ^ 2}$
स्केलर उत्पाद गणना विधि:
$x_1x_2 + y_1y_2 + z_1z_2$
एक वेक्टर उत्पाद की दूसरे वेक्टर के साथ गणना करने की विधि:
$(y_1z_2 - z_1y_2, z_1x_2 - x_1z_2, x_1y_2 - y_1_2_2 -$
$(y_1z_2 - z_1y_2, z_1x_2 - x_1z_2, x_1y_2 - y_1_2_2 -$
एक विधि जो वैक्टर के बीच के कोण (या कोण के कोसाइन) की गणना करती है: वैक्टर के बीच के कोण का कोसाइन वैक्टर के मॉड्यूल (लंबाई) द्वारा विभाजित वैक्टर के स्केलर उत्पाद के बराबर होता है:
$\ frac {(ए, बी)} {| ए | \ cdot | b |}$
योग और अंतर के लिए तरीके:
$(x_1 + x_2, y_1 + y_2, z_1 + z_2)$
$(x_1 - x_2, y_1 - y_2, z_1 - z_2)$
एक स्थिर विधि जो पूर्णांक N को लेती है और आकार N के यादृच्छिक वैक्टर की एक सरणी लौटाती है।

यदि विधि एक वेक्टर लौटाती है, तो उसे एक नई वस्तु वापस करनी चाहिए, और आधार को नहीं बदलना चाहिए। यही है, आपको " अपरिवर्तनीय वस्तु " टेम्पलेट को लागू करने की आवश्यकता है

समाधान:

 public class Vector { //    private double x; private double y; private double z; //    public Vector(double x, double y, double z) { this.x = x; this.y = y; this.z = z; } //  .     public double length() { return Math.sqrt(x * x + y * y + z * z); } // ,    public double scalarProduct(Vector vector) { return x * vector.x + y * vector.y + z * vector.z; } // ,    public Vector crossProduct(Vector vector) { return new Vector( y * vector.z - z * vector.y, z * vector.x - x * vector.z, x * vector.y - y * vector.x); } //     public double cos(Vector vector) { //       // multiply  length return scalarProduct(vector) / (length() * vector.length()); } public Vector add(Vector vector) { return new Vector( x + vector.x, y + vector.y, z + vector.z ); } public Vector subtract(Vector vector) { return new Vector( x - vector.x, y - vector.y, z - vector.z ); } public static Vector[] generate(int n){ Vector[] vectors = new Vector[n]; for(int i =0; i < n; i++){ vectors[i] = new Vector(Math.random(), Math.random(), Math.random()); } return vectors; } @Override public String toString() { return "Vector{" + "x=" + x + ", y=" + y + ", z=" + z + '}'; } }

आप इस वर्ग का उपयोग इस तरह कर सकते हैं:

 public static void main(String[] args) { Vector[] vectors = Vector.generate(10); System.out.println(vectors[0]); System.out.println(vectors[1]); System.out.println(vectors[0].length()); System.out.println(vectors[0].scalarProduct(vectors[1])); System.out.println(vectors[0].crossProduct(vectors[1])); System.out.println(vectors[0].cos(vectors[1])); System.out.println(vectors[0].add(vectors[1])); System.out.println(vectors[0].subtract(vectors[1])); }

आप इस समाधान को सामान्य कर सकते हैं और मनमाने ढंग से आयाम के लिए वेक्टर वर्ग लिख सकते हैं:

 public class Vector { //    ,    private double values[]; public Vector(double[] values) { this.values = values; } //  .     public double length() { double sum = 0; for (int i = 0; i < values.length; i++) { sum += values[i] * values[i]; } return Math.sqrt(sum); } // ,    public double scalarProduct(Vector vector) { double res = 0; for (int i = 0; i < values.length; i++) { res += values[i] * vector.values[i]; } return res; } //     // public double crossProduct(Vector vector) { // // } //     public double cos(Vector vector) { return scalarProduct(vector) / (length() * vector.length()); } public Vector add(Vector vector) { double[] another = new double[values.length]; for (int i = 0; i < values.length; i++) { another[i] = values[i] + vector.values[i]; } return new Vector(another); } public Vector subtract(Vector vector) { double[] another = new double[values.length]; for (int i = 0; i < values.length; i++) { another[i] = values[i] - vector.values[i]; } return new Vector(another); } //   private static double[] generateRandomArray(int length) { double[] array = new double[length]; for (int i = 0; i < array.length; i++) { array[i] = Math.random(); } return array; } public static Vector[] generate(int n, int dimension) { Vector[] vectors = new Vector[n]; for (int i = 0; i < n; i++) { vectors[i] = new Vector(generateRandomArray(dimension)); } return vectors; } }

2.1। वजन के साथ एक यादृच्छिक आइटम बनाना

उद्देश्य:

एक वर्ग लिखें जिसका निर्माता दो सरणियाँ लेता है: मूल्यों की एक सरणी और मूल्यों के भार की एक सरणी।
कक्षा में एक विधि होनी चाहिए जो पहले भार से एक तत्व को बेतरतीब ढंग से लौटाएगी, इसके वजन को ध्यान में रखते हुए।
एक उदाहरण:
एक सरणी दी गई है [1, 2, 3] और भार की एक सरणी [1, 2, 10]।
औसतन, मूल्य "1" को मूल्य "2" से 2 गुना कम और मान "3" से दस गुना कम लौटना चाहिए।

समाधान:

 /*     :  ,   —    .   ""     ,       ,        : |-|--|----------| 0-1--3----------13 ^ */ class RandomFromArray { private int[] values; //  private int[] weights; //  private int[] ranges; //    private int sum; //     public RandomFromArray(int[] values, int[] weights) { this.values = values; this.weights = weights; ranges = new int[values.length]; //     sum = 0; for (int weight : weights) { sum += weight; } //  ranges,   int lastSum = 0; for (int i = 0; i < ranges.length; i++) { ranges[i] = lastSum; lastSum += weights[i]; } } /*  ranges  ,        [0;sum],   ,   : */ public int getRandom() { int random = (int) (Math.random() * (sum - 1)); int ourRangeIndex = 0; for (int i = 0; i < ranges.length; i++) { if (ranges[i] > random) { break; } ourRangeIndex = i; } return values[ourRangeIndex]; } }

लेकिन, चूंकि श्रेणी सरणी क्रमबद्ध है, आप बाइनरी खोज का उपयोग (और कर सकते हैं):

 public int getRandom() { int random = (int) (Math.random() * (sum - 1)); int index = Arrays.binarySearch(ranges, random); return values[index >= 0 ? index : -index - 2]; }

इस समस्या का एक और समाधान है। आप एक सरणी बना सकते हैं जिसका आकार सभी भार के योग के बराबर है। फिर एक यादृच्छिक सूचकांक का चुनाव एक यादृच्छिक सूचकांक उत्पन्न करने के लिए नीचे आता है। यही है, यदि मानों का एक सरणी [1, 2, 3], और भार का एक सरणी [1, 2, 10] दिया गया है, तो आप तुरंत [1, 2, 2, 3, 3, 3, 3, 3, 3] का एक सरणी बना सकते हैं। 3, 3, 3, 3] और इसमें से एक यादृच्छिक तत्व निकालें:

 class RandomFromArray { private int[] extended_values; //  public RandomFromArray(int[] values, int[] weights) { //     int sum = 0; for (int weight : weights) { sum += weight; } extended_values = new int[sum]; int cursor = 0; for(int i = 0; i < weights.length; i++){ for(int j = 0; j < weights[i]; j++){ extended_values[cursor++] = values[i]; } } } /*  extended_values  ,        [0; extended_values.length) */ public int getRandom() { int random = (int) (Math.random() * ( extended_values.length - 1)); return extended_values[random]; } }

इस समाधान का एक फायदा है - पिछले समाधान में लॉग (n) के विपरीत एक यादृच्छिक तत्व O (1) निकालने का समय। हालाँकि, इसके लिए बहुत अधिक मेमोरी की आवश्यकता होती है:

$O (\ योग _ {} {n})$

2.2। लिंक की गई सूची

एक और कार्य जो मैं अक्सर देता हूं वह एक लिंक की गई सूची का कार्यान्वयन है। यह अपने सरलतम रूप में दिया जा सकता है (लागू जोड़ें () और प्राप्त करें (केवल )), या आप java.util.List को लागू करने के लिए कह सकते हैं।
मैं इस पर विस्तार से ध्यान नहीं दूंगा, जावा में हैबर में एक लिंक्ड सूची के कार्यान्वयन पर कई लेख हैं, उदाहरण के लिए यह एक:
चित्रों में डेटा संरचनाएं। LinkedList

3.0। बाइनरी सर्च

उद्देश्य:

एक विधि लिखिए जो जाँचता है कि दिया गया तत्व ऐरे में है या नहीं।
इस समस्या को हल करने के लिए गणना और द्विआधारी खोज का उपयोग करें।
बड़े सरणियों के लिए दोनों समाधानों के क्रम की तुलना करें (जैसे कि 100000000 तत्व)।
समाधान:

  /*  ,   .    ,  -1 */ public static int bruteForce(double[] array, double key) { for (int i = 0; i < array.length; i++) { if (array[i] == key) return i; } return -1; } /*   */ public static int binarySearchRecursively(double[] sortedArray, double key) { return binarySearchRecursively(sortedArray, key, 0, sortedArray.length); } /** *    {@link #binarySearchRecursively(double[], double)} * *    ,   ,   " ", *      .    low  high * * @param sortedArray   * @param key   * @param low     * @param high     * @return   */ private static int binarySearchRecursively (double[] sortedArray, double key, int low, int high) { int middle = (low + high) / 2; //  if (high < low) { //    return -1; } if (key == sortedArray[middle]) { //   return middle; } else if (key < sortedArray[middle]) { //     return binarySearchRecursively( sortedArray, key, low, middle - 1); } else { return binarySearchRecursively( //     sortedArray, key, middle + 1, high); } } //     private static double[] generateRandomArray(int length) { double[] array = new double[length]; for (int i = 0; i < array.length; i++) { array[i] = Math.random(); } return array; } public static void main(String[] args) { double[] array = generateRandomArray(100000000); Arrays.sort(array); //    /*  ,       ,   benchmarks . https://habr.com/ru/post/349914/     */ long time = System.currentTimeMillis(); //  , unix-time bruteForce(array, 0.5); System.out.println(System.currentTimeMillis() - time); time = System.currentTimeMillis(); binarySearchRecursively(array, 0.5); System.out.println(System.currentTimeMillis() - time); }

3.1। समीकरण की जड़ ज्ञात कीजिए

उद्देश्य:

समीकरण की जड़ ज्ञात कीजिए

$cos (x ^ 5) + x ^ 4 - 345.3 * x - 23 = 0$

खंड पर [0; 10] x में सटीकता के साथ 0.001 से खराब नहीं है। यह ज्ञात है कि जड़ इस अंतराल में अद्वितीय है।
इसके लिए हल करने की विधि (और पुनरावृत्ति) का उपयोग करें।

समाधान:

  //   public static double func(double x){ return Math.cos(Math.pow(x, 5)) + Math.pow(x, 4) - 345.3 * x - 23; } //   public static double solve(double start, double end){ if(end - start <= 0.001){ return start; } double x = start + (end - start) / 2; if(func(start) * func(x) > 0){ return solve(x, end); } else { return solve(start, x); } } public static void main(String[] args) { System.out.println(solve(0, 10)); }

नोट: यदि हम x में , y में आवश्यक सटीकता प्राप्त नहीं करना चाहते हैं, तो विधि में स्थिति को फिर से लिखना चाहिए:

  if(Math.abs(func(start)- func(end)) <= 0.001){ return start; }

एक छोटी सी चाल: यह देखते हुए कि दोहरे मानों का सेट परिमित है (दो आसन्न मूल्य हैं जिनके बीच कोई दोहरा मूल्य नहीं हैं), निम्नानुसार पुनरावृत्ति से बाहर निकलने की स्थिति को फिर से लिखते हैं:

  double x = start + (end - start) / 2; if(x == end || x == start){ return x; }

इस प्रकार, हम अधिकतम सटीकता प्राप्त करते हैं जो आम तौर पर इस दृष्टिकोण का उपयोग करके प्राप्त की जा सकती है।

3.2। बाइनरी सर्च ट्री

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

विरासत

4.0। एक वर्ग पदानुक्रम को लागू करें जो तीन आयामी आकृतियों का वर्णन करता है

उद्देश्य:

एक वर्ग पदानुक्रम को लागू करें:

बॉक्स क्लास एक कंटेनर है, इसमें अन्य आकृतियाँ हो सकती हैं। ऐड () विधि आकार को इनपुट के रूप में लेती है। जब तक हम बॉक्स में उनके लिए जगह नहीं लेंगे तब तक हमें नए आकार जोड़ने होंगे (हम केवल मात्रा पर विचार करेंगे, आकार की अनदेखी करेंगे। मान लीजिए कि हम तरल कर सकते हैं)। यदि एक नया आकार जोड़ने के लिए पर्याप्त जगह नहीं है, तो विधि झूठी वापस आनी चाहिए।

समाधान:

 class Shape { private double volume; public Shape(double volume) { this.volume = volume; } public double getVolume() { return volume; } } class SolidOfRevolution extends Shape { private double radius; public SolidOfRevolution(double volume, double radius) { super(volume); this.radius = radius; } public double getRadius() { return radius; } } class Ball extends SolidOfRevolution { //   public Ball(double radius) { super(Math.PI * Math.pow(radius, 3) * 4 / 3, radius); } } class Cylinder extends SolidOfRevolution { //   private double height; public Cylinder(double radius, double height) { super(Math.PI * radius * radius * height, radius); this.height = height; } } class Pyramid extends Shape{ private double height; private double s; //   public Pyramid(double height, double s) { super(height * s * 4 / 3); this.height = height; this.s = s; } } class Box extends Shape { private ArrayList<Shape> shapes = new ArrayList<>(); private double available; public Box(double available) { super(available); this.available = available; } public boolean add(Shape shape) { if (available >= shape.getVolume()) { shapes.add(shape); available -= shape.getVolume(); return true; } else { return false; } } } public class Main { public static void main(String[] args) { Ball ball = new Ball(4.5); Cylinder cylyinder = new Cylinder(2, 2); Pyramid pyramid = new Pyramid(100, 100); Box box = new Box(1000); System.out.println(box.add(ball)); // ok System.out.println(box.add(cylyinder)); // ok System.out.println(box.add(pyramid)); // failed } }

इस कार्य में वापस नहीं आने के लिए, इस कार्य के कई और रूप नीचे वर्णित हैं।

4.1। एक वर्ग पदानुक्रम को लागू करें जो तीन आयामी आकृतियों का वर्णन करता है - 2

उद्देश्य:

एक ही वर्ग पदानुक्रम को लागू करें, लेकिन कुछ कक्षाएं अमूर्त करें।

समाधान:

 abstract class Shape { public abstract double getVolume(); } abstract class SolidOfRevolution extends Shape { protected double radius; public SolidOfRevolution(double radius) { this.radius = radius; } public double getRadius() { return radius; } } class Ball extends SolidOfRevolution { //   @Override public double getVolume() { return Math.PI * Math.pow(radius, 3) * 4 / 3; } public Ball(double radius) { super(radius); } } class Cylinder extends SolidOfRevolution { //   private double height; public Cylinder(double radius, double height) { super(radius); this.height = height; } @Override public double getVolume() { return Math.PI * radius * radius * height; } } class Pyramid extends Shape { private double height; private double s; //   public Pyramid(double height, double s) { this.height = height; this.s = s; } @Override public double getVolume() { return height * s * 4 / 3; } } class Box extends Shape { private ArrayList<Shape> shapes = new ArrayList<>(); private double available; private double volume; public Box(double available) { this.available = available; this.volume = available; } public boolean add(Shape shape) { if (available >= shape.getVolume()) { shapes.add(shape); available -= shape.getVolume(); return true; } else { return false; } } @Override public double getVolume() { return volume; } } public class Main { public static void main(String[] args) { Ball ball = new Ball(4.5); Cylinder cylyinder = new Cylinder(2, 2); Pyramid pyramid = new Pyramid(100, 100); Box box = new Box(1000); System.out.println(box.add(ball)); // ok System.out.println(box.add(cylyinder)); // ok System.out.println(box.add(pyramid)); // failed } }

4.2। एक वर्ग पदानुक्रम को लागू करें जो तीन आयामी आकृतियों का वर्णन करता है - 3

उद्देश्य:

एक ही वर्ग पदानुक्रम को लागू करें, लेकिन इंटरफेस का उपयोग करना।
इसके अतिरिक्त, छात्रों को तुलनात्मक इंटरफ़ेस को लागू करने के लिए प्रोत्साहित किया जाता है।

समाधान:

 interface Shape extends Comparable<Shape>{ double getVolume(); @Override default int compareTo(Shape other) { return Double.compare(getVolume(), other.getVolume()); } } abstract class SolidOfRevolution implements Shape { protected double radius; public SolidOfRevolution(double radius) { this.radius = radius; } public double getRadius() { return radius; } } class Ball extends SolidOfRevolution { //   @Override public double getVolume() { return Math.PI * Math.pow(radius, 3) * 4 / 3; } public Ball(double radius) { super(radius); } } class Cylinder extends SolidOfRevolution { //   private double height; public Cylinder(double radius, double height) { super(radius); this.height = height; } @Override public double getVolume() { return Math.PI * radius * radius * height; } } class Pyramid implements Shape { private double height; private double s; //   public Pyramid(double height, double s) { this.height = height; this.s = s; } @Override public double getVolume() { return height * s * 4 / 3; } } class Box implements Shape { private ArrayList<Shape> shapes = new ArrayList<>(); private double available; private double volume; public Box(double available) { this.available = available; this.volume = available; } public boolean add(Shape shape) { if (available >= shape.getVolume()) { shapes.add(shape); available -= shape.getVolume(); return true; } else { return false; } } @Override public double getVolume() { return volume; } public ArrayList<Shape> getShapes() { return shapes; } } public class Main { public static void main(String[] args) { Ball ball = new Ball(4.5); Cylinder cylyinder = new Cylinder(2, 2); Pyramid pyramid = new Pyramid(100, 100); Box box = new Box(1000); System.out.println(box.add(ball)); // ok System.out.println(box.add(cylyinder)); // ok System.out.println(box.add(pyramid)); // failed // Sorting: ArrayList<Shape> shapes = box.getShapes(); Collections.sort(shapes); // sorted by Volume! } }

4.3। एक वर्ग पदानुक्रम को लागू करें जो तीन आयामी आकृतियों का वर्णन करता है - 4

उद्देश्य:

एक मनमाना समारोह के लिए वर्ग पदानुक्रम के लिए एक रोटेशन आकार जोड़ें। आप एक निश्चित अभिन्न का उपयोग करके अनुमानित मात्रा की गणना कर सकते हैं। चूंकि एक्स अक्ष के चारों ओर घूर्णन आकृति का आयतन है

$V_x = \ pi \ int_ {a} ^ {b} f ^ 2 (x) dx$

और अभिन्न है

$छवि$

तब आप आयत विधि का कार्यान्वयन लिख सकते हैं:

 class SolidRevolutionForFunction extends SolidOfRevolution { private Function<Double, Double> function; private double a; private double b; public SolidRevolutionForFunction( Function<Double, Double> function, double a, double b) { super(b - a); this.function = function; this.a = a; this.b = b; } @Override public double getVolume() { double sum = 0; int iterations = 10000; double delta = (b - a)/iterations; for(int i = 0; i < iterations; i++){ double x = a + ((b - a) * i/iterations); sum += Math.pow(function.apply(x), 2) * delta; } return Math.PI * sum; } }

 public static void main(String[] args) { Shape shape = new SolidRevolutionForFunction(new Function<Double, Double>() { @Override public Double apply(Double x) { return Math.cos(x); } }, 0, 10); System.out.println(shape.getVolume()); }

बेशक, हम यहां गणना की सटीकता को ध्यान में नहीं रखते हैं, और हम आवश्यक सटीकता प्राप्त करने के लिए विभाजन की संख्या का चयन नहीं करते हैं, लेकिन यह एक प्रोग्रामिंग कार्य है, संख्यात्मक तरीके नहीं है, इसलिए हम कक्षा में इसे छोड़ देते हैं।

पंक्तियां

आप प्रति पंक्ति बहुत सारे कार्य पा सकते हैं। मैं आमतौर पर ये देता हूं:

किसी सरणी में सबसे लंबी स्ट्रिंग खोजने के लिए एक विधि लिखें।
एक विधि लिखें जो यह जांचती है कि क्या शब्द एक पैलिंड्रोम है ।
एक विधि लिखिए जो टेक्स्ट में ~~बल्क~~ "बायका" शब्द की सभी घटनाओं को "कट आउट" के साथ बदल देती है
सेंसर किया हुआ] "
दो लाइनें हैं। एक विधि लिखें जो एक पंक्ति की घटनाओं की संख्या को दूसरे में लौटाती है।

मैं ऐसी समस्याओं के समाधान का वर्णन नहीं करूंगा, और स्ट्रिंग्स के लिए भी बड़ी संख्या में कार्य हैं।

अधिक दिलचस्प लोगों में से, मुझे यह पसंद है:

5.0। रूसी (या अंग्रेजी) वर्णमाला के अक्षरों की आवृत्ति शब्दकोश।

उद्देश्य:

रूसी (या अंग्रेजी) वर्णमाला के अक्षरों का एक आवृत्ति शब्दकोश बनाएँ। हम भाषा के शरीर को चुनने और विश्लेषण करने की समस्या को छोड़ देते हैं, यह छोटी लंबाई के पाठ को लेने के लिए पर्याप्त होगा)।

समाधान:

  /** *      ,  *      , *    Map. * *    Map.Entry<Character, Integer>, *     (Character) * * @param text -  */ void buildDictionaryWithMap(String text){ text = text.toLowerCase(); Map<Character, Integer> map = new HashMap<>(); for(int i = 0; i < text.length(); i++){ char ch = text.charAt(i); //     - if((ch >= '' && ch <= '') || ch == ''){ map.compute(ch, (character, integer) -> integer == null ? 1 : integer + 1); } } ArrayList<Map.Entry<Character, Integer>> entries = new ArrayList<>(map.entrySet()); entries.sort((o1, o2) -> Character.compare(o1.getKey(), o2.getKey())); for(Map.Entry<Character, Integer> entry : entries){ System.out.println(entry.getKey() + " " + entry.getValue()); } }

या तो:

  /** *   Map. *    ,    *      *  * @param text */ void buildDictionary(String text){ text = text.toLowerCase(); int[] result = new int['' - '' + 1]; for(int i = 0; i < text.length(); i++){ char ch = text.charAt(i); if(ch >= '' && ch <= ''){ result[ch - '']++; } } for(int i = 0; i < result.length; i++){ System.out.println((char) (i + '') + " = " + result[i]); } }

सार वर्ग और इंटरफेस

6.0। तापमान कनवर्टर

उद्देश्य:

डिग्री सेल्सियस से में परिवर्तित करने के लिए एक BaseConverter वर्ग लिखें
केल्विन , फ़ारेनहाइट , और इसी तरह। विधि में एक कनवर्ट विधि होनी चाहिए, जो
और रूपांतरण करता है।

समाधान:

 interface Converter { double getConvertedValue(double baseValue); } class CelsiusConverter implements Converter { @Override public double getConvertedValue(double baseValue) { return baseValue; } } class KelvinConverter implements Converter { @Override public double getConvertedValue(double baseValue) { return baseValue + 273.15; } } class FahrenheitConverter implements Converter { @Override public double getConvertedValue(double baseValue) { return 1.8 * baseValue + 32; } } public class Main { public static void main(String[] args) { double temperature = 23.5; System.out.println("t = " + new CelsiusConverter().getConvertedValue(temperature)); System.out.println("t = " + new KelvinConverter().getConvertedValue(temperature)); System.out.println("t = " + new FahrenheitConverter().getConvertedValue(temperature)); } }

इसके अतिरिक्त, आप एक कारखाने विधि को लागू करने के लिए कह सकते हैं , कुछ इस तरह से:

 interface Converter { double getConvertedValue(double baseValue); public static Converter getInstance(){ Locale locale = Locale.getDefault(); String[] fahrenheitCountries = {"BS", "US", "BZ", "KY", "PW"}; boolean isFahrenheitCountry = Arrays.asList(fahrenheitCountries).contains(locale.getCountry()); if(isFahrenheitCountry){ return new FahrenheitConverter(); } else { return new CelsiusConverter(); } } }

6.1। पूर्ववत समर्थन के साथ स्ट्रिंगर

कार्य: पूर्ववत

संचालन के लिए समर्थन के साथ अपने स्ट्रिंगबर्ल क्लास को लिखें । ऐसा करने के लिए, मानक StringBuilder के लिए सभी विधियों को निर्दिष्ट करें , और अपनी खुद की कक्षा में निष्पादित करने के लिए पूर्ववत () के सभी कार्यों की एक सूची संग्रहीत करें । यह टीम टेम्पलेट का कार्यान्वयन होगा । समाधान:

 /** * StringBuilder    undo * java.lang.StringBuilder —    <b>final</b>, *   ,  . */ class UndoableStringBuilder { private interface Action{ void undo(); } private class DeleteAction implements Action{ private int size; public DeleteAction(int size) { this.size = size; } public void undo(){ stringBuilder.delete( stringBuilder.length() - size, stringBuilder.length()); } } private StringBuilder stringBuilder; //  /** * ,   . *     append,    *  "delete".   undo()  *  . */ private Stack<Action> actions = new Stack<>(); //  public UndoableStringBuilder() { stringBuilder = new StringBuilder(); } /** see {@link java.lang.AbstractStringBuilder#reverse()}  ,   reverse(),      —  reverse().    . */ public UndoableStringBuilder reverse() { stringBuilder.reverse(); Action action = new Action(){ public void undo() { stringBuilder.reverse(); } }; actions.add(action); return this; } public UndoableStringBuilder append(String str) { stringBuilder.append(str); Action action = new Action(){ public void undo() { stringBuilder.delete( stringBuilder.length() - str.length() -1, stringBuilder.length()); } }; actions.add(action); return this; } // .....    append   (. )...... public UndoableStringBuilder appendCodePoint(int codePoint) { int lenghtBefore = stringBuilder.length(); stringBuilder.appendCodePoint(codePoint); actions.add(new DeleteAction(stringBuilder.length() - lenghtBefore)); return this; } public UndoableStringBuilder delete(int start, int end) { String deleted = stringBuilder.substring(start, end); stringBuilder.delete(start, end); actions.add(() -> stringBuilder.insert(start, deleted)); return this; } public UndoableStringBuilder deleteCharAt(int index) { char deleted = stringBuilder.charAt(index); stringBuilder.deleteCharAt(index); actions.add(() -> stringBuilder.insert(index, deleted)); return this; } public UndoableStringBuilder replace(int start, int end, String str) { String deleted = stringBuilder.substring(start, end); stringBuilder.replace(start, end, str); actions.add(() -> stringBuilder.replace(start, end, deleted)); return this; } public UndoableStringBuilder insert(int index, char[] str, int offset, int len) { stringBuilder.insert(index, str, offset, len); actions.add(() -> stringBuilder.delete(index, len)); return this; } public UndoableStringBuilder insert(int offset, String str) { stringBuilder.insert(offset, str); actions.add(() -> stringBuilder.delete(offset, str.length())); return this; } // .....    insert   (. )...... public void undo(){ if(!actions.isEmpty()){ actions.pop().undo(); } } public String toString() { return stringBuilder.toString(); } }

6.2। राज्य निर्माण स्ट्रिंगर (पर्यवेक्षक पैटर्न)

कार्य:

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

समाधान:

 /** .  ,      UndoableStringBuilder,   onChange(). */ interface OnStringBuilderChangeListener { void onChange(OvservableStringBuilder stringBuilder); } class OvservableStringBuilder { // ,     private OnStringBuilderChangeListener onChangeListener; //  private StringBuilder stringBuilder; //   onChangeListener public void setOnChangeListener(OnStringBuilderChangeListener onChangeListener) { this.onChangeListener = onChangeListener; } public OvservableStringBuilder() { stringBuilder = new StringBuilder(); } private void notifyOnStringBuilderChangeListener(){ if(onChangeListener != null){ onChangeListener.onChange(this); } } public OvservableStringBuilder append(Object obj) { stringBuilder.append(obj); notifyOnStringBuilderChangeListener(); return this; } public OvservableStringBuilder replace(int start, int end, String str) { stringBuilder.replace(start, end, str); notifyOnStringBuilderChangeListener(); return this; } public OvservableStringBuilder insert(int index, char[] str, int offset, int len) { stringBuilder.insert(index, str, offset, len); notifyOnStringBuilderChangeListener(); return this; } // .......    .......... public String toString() { return stringBuilder.toString(); } } /**   OnStringBuilderChangeListener */ class MyListener implements OnStringBuilderChangeListener { /*   onChange    stringBuilder,  "" */ public void onChange(OvservableStringBuilder stringBuilder) { System.out.println("CHANGED: " + stringBuilder.toString()); } } public class Main { public static void main(String[] strings) { OvservableStringBuilder UndoableStringBuilder = new OvservableStringBuilder(); UndoableStringBuilder.setOnChangeListener(new MyListener()); UndoableStringBuilder.append("Hello"); UndoableStringBuilder.append(", "); UndoableStringBuilder.append("World!"); } }

6.3। फिल्टर

समस्या:

लिखें विधि फिल्टर , जो इनपुट सरणी (किसी भी प्रकार की) प्राप्त करता है, और इंटरफ़ेस के कार्यान्वयन फ़िल्टर सी विधि लागू (वस्तु ओ) , सरणी से दूर करने के लिए ज़रूरत से ज़्यादा।
जांचें कि यह स्ट्रिंग्स या अन्य वस्तुओं पर कैसे काम करता है।

समाधान:
आमतौर पर, मैं इस कार्य को जेनरिक से पहले देता हूं, इसलिए छात्र ऑब्जेक्ट का उपयोग किए बिना एक विधि लिखते हैं:

 interface Filter { boolean apply(Object o); } public class Main { public static Object[] filter(Object[] array, Filter filter) { int offset = 0; for(int i = 0; i< array.length; i++){ if(!filter.apply(array[i])){ offset++; } else{ array[i - offset] = array[i]; } } // Arrays.copyOf     array    //   array.length - offset return Arrays.copyOf(array, array.length - offset); } public static void main(String[] args) { String array[] = new String[]{"1rewf ", "feefewf", "a", null, "1"}; String[] newArray = (String[]) filter(array, new Filter() { @Override public boolean apply(Object o) { return o != null; } }); } }

लेकिन, यह जेनरिक के साथ संभव है। तो फिर तुम मानक का उपयोग कर सकते समारोह :

 public class Main { public static <T> T[] filter(T[] array, Function<? super T, Boolean> filter) { int offset = 0; for (int i = 0; i < array.length; i++) { if (!filter.apply(array[i])) { offset++; } else { array[i - offset] = array[i]; } } // Arrays.copyOf     array    //   array.length - offset return Arrays.copyOf(array, array.length - offset); } public static void main(String[] args) { String array[] = new String[]{"1rewf ", "feefewf", "a", null, "1"}; String[] newArray = filter(array, s -> s != null); } }

6.4। एरे फिलिंग

पिछले एक के समान कुछ कार्य:
एक भरने की विधि लिखें जो वस्तुओं की एक सरणी और फ़ंक्शन इंटरफ़ेस (या अपने खुद के) के कार्यान्वयन को स्वीकार करता है।
भरण पद्धति को सारणी को भरना चाहिए, फ़ंक्शन इंटरफ़ेस के कार्यान्वयन का उपयोग करके सूचकांक द्वारा नया मूल्य प्राप्त करना चाहिए। यही है, आप इसे इस तरह से उपयोग करना चाहते हैं:

 public static void main(String[] args) { Integer[] squares = new Integer[100]; fill(squares, integer -> integer * integer); // 0, 1, 4, 9, 16 ..... }

समाधान:

 public static <T> void fill(T[] objects, Function<Integer, ? extends T> function) { for(int i = 0; i < objects.length; i++){ objects[i] = function.apply(i); } }

संग्रह

7.0। फ्रीक्वेंसी डिक्शनरी ऑफ वर्ड्स

वर्णमाला के अक्षरों के आवृत्ति शब्दकोश के बारे में समस्या देखें

7.1। डुप्लिकेट के बिना संग्रह

कार्य:

एक विधि लिखें जो एक इनपुट के रूप में वस्तुओं का संग्रह प्राप्त करता है, और डुप्लिकेट के बिना एक संग्रह लौटाता है।

समाधान:

  public static <T> Collection<T> removeDuplicates(Collection<T> collection) { return new HashSet<>(collection); //   ! }

7.2। ArrayList और LinkedList

एक ऐसा तरीका लिखें जो 1,000,000 तत्वों को एक ArrayList और LinkedList में जोड़ता है। एक अन्य विधि लिखिए जो भरी हुई सूची में से 100,000 बार यादृच्छिक रूप से एक तत्व का चयन करती है। इस पर बिताए समय को मापें। परिणामों की तुलना करें और सुझाव दें कि वे क्यों हैं।

समाधान:

  public static void compare2Lists() { ArrayList<Double> arrayList = new ArrayList<>(); LinkedList<Double> linkedList = new LinkedList<>(); final int N = 1000000; final int M = 1000; for (int i = 0; i < N; i++) { arrayList.add(Math.random()); linkedList.add(Math.random()); } long startTime = System.currentTimeMillis(); for (int i = 0; i < M; i++) { arrayList.get((int) (Math.random() * (N - 1))); } System.out.println(System.currentTimeMillis() - startTime); startTime = System.currentTimeMillis(); for (int i = 0; i < M; i++) { linkedList.get((int) (Math.random() * (N - 1))); } System.out.println(System.currentTimeMillis() - startTime); }

7.3। एक सरणी पर एक पुनरावृत्त लिखें

समाधान:

 class ArrayIterator<T> implements Iterator<T>{ private T[] array; private int index = 0; public ArrayIterator(T[] array) { this.array = array; } @Override public boolean hasNext() { return index < array.length; } @Override public T next() { if(!hasNext()) throw new NoSuchElementException(); return array[index++]; } }

7.4। द्वि-आयामी सरणी पुनरावृत्ति

कार्य:

द्वि-आयामी सरणी पर एक पुनरावृत्त लिखें।

समाधान:

 class Array2d<T> implements Iterable<T>{ private T[][] array; public Array2d(T[][] array) { this.array = array; } @Override public Iterator<T> iterator() { return new Iterator<T>() { private int i, j; @Override public boolean hasNext() { for(int i = this.i; i< array.length; i++){ for(int j = this.j; j< array[i].length; j++){ return true; } } return false; } @Override public T next() { if(!hasNext()) throw new NoSuchElementException(); T t = array[i][j]; j++; for(int i = this.i; i< array.length; i++){ for(int j = (i == this.i ? this.j : 0); j< array[i].length; j++){ this.i = i; this.j = j; return t; } } return t; } }; } }

7.5। एक और भी अधिक जटिल पुनरावृत्ति

मुझे यह कार्य पसंद है। वह समूह में कुछ ही छात्रों तक पहुँचती है जो पिछले कार्यों का सामना करने में अपेक्षाकृत आसान होते हैं।

कार्य:

दान पुनरावृत्ति। अगली () पद्धति या तो एक स्ट्रिंग या एक ही संरचना का एक पुनरावृत्तिकर्ता (जो कि फिर से स्ट्रिंग या समान पुनरावर्तक लौटाता है) देता है। इस पुनरावृत्ति के शीर्ष पर लिखें, पहले से ही "फ्लैट" एक।

ढेर पर समाधान:

 public class DeepIterator implements Iterator<String> { private Stack<Iterator> iterators; private String next; private boolean hasNext; public DeepIterator(Iterator<?> iterator) { this.iterators = new Stack<Iterator>(); iterators.push(iterator); updateNext(); } @Override public boolean hasNext() { return hasNext; } private void updateNext(){ if(iterators.empty()){ next = null; hasNext = false; return; } Iterator current = iterators.peek(); if (current.hasNext()) { Object o = current.next(); if (o instanceof String) { next = (String) o; hasNext = true; } else if (o instanceof Iterator) { Iterator iterator = (Iterator) o; iterators.push(iterator); updateNext(); } else { throw new IllegalArgumentException(); } } else { iterators.pop(); updateNext(); } } @Override public String next() throws NoSuchElementException { if(!hasNext){ throw new NoSuchElementException(); } String nextToReturn = next; updateNext(); return nextToReturn; } @Override public void remove() { throw new UnsupportedOperationException(); } }

पुनरावर्ती समाधान:

 /** * @author Irina Poroshina */ class DeepIterator implements Iterator<String> { private Iterator subIter; private DeepIterator newIter; public DeepIterator(Iterator iniIter) { this.subIter = iniIter; } @Override public boolean hasNext() { if (subIter.hasNext()) return true; if (newIter != null) return newIter.hasNext(); return false; } @Override public String next() { if(!hasNext()) throw new NoSuchElementException(); Object obj = null; if (newIter != null && newIter.hasNext()) obj = newIter.next(); if (subIter.hasNext() && obj == null) { obj = subIter.next(); if (obj instanceof Iterator && ((Iterator) obj).hasNext()) { newIter = new DeepIterator((Iterator) obj); } } if(obj instanceof Iterator){ obj = next(); } return (String) obj; } }

7.6। दो पुनरावृत्तियों पर Iterator

कार्य:

एक पुनरावृति लिखने वाला जो दो पुनरावृत्तियों से गुजरता है।

समाधान:

 /** * @author Irina Poroshina */ class ConcatIterator<T> implements Iterator<T> { private Iterator<T> innerIterator1; private Iterator<T> innerIterator2; public ConcatIterator (Iterator<T> innerIterator1, Iterator<T> innerIterator2) { this.innerIterator1 = innerIterator1; this.innerIterator2 = innerIterator2; } @Override public boolean hasNext() { while (innerIterator1.hasNext()) return true; while (innerIterator2.hasNext()) return true; return false; } @Override public T next() { if(!hasNext()) throw new NoSuchElementException(); while (innerIterator1.hasNext()) return innerIterator1.next(); while (innerIterator2.hasNext()) return innerIterator2.next(); return null; } }

7.7। गिनती के तत्व

एक विधि लिखें जो इनपुट के रूप में K (जेनेरिक) प्रकार के तत्वों की एक सरणी प्राप्त करता है और नक्शा <K, Integer> देता है, जहां K सरणी से मान है और Integer सरणी में प्रविष्टियों की संख्या है।
यह है, विधि हस्ताक्षर इस तरह दिखता है:

 <K> Map<K, Integer> arrayToMap(K[] ks);

समाधान:

 public static <K> Map<K, Integer> countValues(K[] ks) { Map<K, Integer> map = new HashMap<>(); for (K k : ks) { map.compute(k, new BiFunction<K, Integer, Integer>() { @Override public Integer apply(K k, Integer count) { return count == null ? 1 : count + 1; } }); } return map; }

7.8। मानचित्र में चाबियाँ और मूल्य बदलें

मैप <के, वी> प्राप्त करने वाली एक विधि लिखें और मैप को लौटाएं, जहां चाबियाँ और मूल्य उलट हैं। चूंकि मान संयोग कर सकते हैं, मैप में मान प्रकार अब K नहीं होगा , लेकिन

 संग्रह <K>:

 Map<V, Collection<K>>

समाधान:

 public static <K, V> Map<V, Collection<K>> inverse(Map<? extends K, ? extends V> map){ Map<V, Collection<K>> resultMap = new HashMap<>(); Set<K> keys = map.keySet(); for(K key : keys){ V value = map.get(key); resultMap.compute(value, (v, ks) -> { if(ks == null){ ks = new HashSet<>(); } ks.add(key); return ks; }); } return resultMap; }

बहु सूत्रण

8.0। राज्यों

कार्य:

प्रारंभ होने से पहले, और रनटाइम के बाद स्ट्रीम की स्थिति को प्रिंट करें।

समाधान:

  Thread thread = new Thread() { @Override public void run() { System.out.println(getState()); } }; System.out.println(thread.getState()); thread.start(); try { //         TERMINATED: thread.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(thread.getState());

जोड़ें और अवरुद्ध:

  /** *   WAITING * * @param strings * @throws InterruptedException */ public static void main(String[] strings) throws InterruptedException { Object lock = new Object(); Thread thread = new Thread() { @Override public void run() { try { synchronized (lock) { lock.notifyAll(); lock.wait(); } } catch (InterruptedException e) { e.printStackTrace(); } } }; synchronized (lock){ thread.start(); //   lock.wait(); //  ,     System.out.println(thread.getState()); // WAITING lock.notifyAll(); System.out.println(thread.getState()); // BLOCKED } }

के लिए TIMED_WAITING थोड़ा ही कोड को संशोधित:

  /** *   WAITING * * @param strings * @throws InterruptedException */ public static void main(String[] strings) throws InterruptedException { Object lock = new Object(); Thread thread = new Thread() { @Override public void run() { try { synchronized (lock) { lock.notifyAll(); lock.wait(3000); } } catch (InterruptedException e) { e.printStackTrace(); } } }; synchronized (lock) { thread.start(); //   lock.wait(); //  ,     System.out.println(thread.getState()); // WAITING } }

8.1। धागा सिंक्रनाइज़ेशन

कार्य:

एक प्रोग्राम लिखें जिसमें दो थ्रेड बनाए जाते हैं जो बदले में कंसोल पर अपना नाम प्रदर्शित करते हैं।

समाधान:

 class StepThread extends Thread { //     lock private Object lock; public StepThread(Object object) { this.lock = object; } /** *  :   ,   , *     ,  ,    . * *     lock.notify()   *   ,  , *  lock   .    ,   *  lock.wait(),      .    . */ @Override public void run() { while (true) { synchronized (lock) { try { System.out.println(getName()); lock.notify(); lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } public class Main { public static void main(String[] strings) { Object lock = new Object(); new StepThread(lock).start(); new StepThread(lock).start(); } }

8.2। निर्माता-उपभोक्त

क्लासिक मल्टीथ्रेडिंग कार्यों में से एक। दो धाराओं को देखते हुए - निर्माता और उपभोक्ता। निर्माता कुछ डेटा (उदाहरण में, संख्या) उत्पन्न करता है। निर्माता उन्हें "खपत" करता है।
दो स्ट्रीम एक सामान्य डेटा बफर साझा करते हैं, जिसका आकार सीमित है। यदि बफर खाली है, तो उपभोक्ता को डेटा के वहां प्रदर्शित होने का इंतजार करना चाहिए। यदि बफर भरा हुआ है, तो निर्माता को तब तक इंतजार करना चाहिए जब तक कि उपभोक्ता डेटा नहीं ले लेता है और जगह खाली हो जाती है।

निर्माता:

 // implements Runnable      class Producer implements Runnable { //   private final Queue<Double> sharedQueue; //   private final int SIZE; //  public Producer(Queue<Double> sharedQueue, int size) { this.sharedQueue = sharedQueue; this.SIZE = size; } @Override public void run() { //   while (true) { try { //     produce System.out.println("Produced: " + produce()); } catch (InterruptedException e) { e.printStackTrace(); } } } private double produce() throws InterruptedException { synchronized (sharedQueue) { //  synchronized if (sharedQueue.size() == SIZE) { //   ,   sharedQueue.wait(); } //    . double newValue = Math.random(); sharedQueue.add(newValue); //     ,    sharedQueue.notifyAll(); return newValue; } } }

उपभोक्ता:

 // implements Runnable      class Consumer implements Runnable { //   private final Queue<Double> sharedQueue; public Consumer(Queue<Double> sharedQueue) { this.sharedQueue = sharedQueue; } @Override public void run() { while (true) { try { System.out.println("Consumed: " + consume()); } catch (InterruptedException ex) { ex.printStackTrace(); } } } // ,      private Double consume() throws InterruptedException { synchronized (sharedQueue) { if (sharedQueue.isEmpty()) { //  ,   sharedQueue.wait(); } sharedQueue.notifyAll(); return sharedQueue.poll(); } } }

बनाएं और चलाएं:

 public static void main(String[] strings) { LinkedList<Double> sharedQueue = new LinkedList<>(); int size = 4; Thread prodThread = new Thread(new Producer(sharedQueue, size), "Producer"); Thread consThread = new Thread(new Consumer(sharedQueue), "Consumer"); prodThread.start(); consThread.start(); }

9.0। खुद का एनोटेशन - निर्माण और उपयोग

मैं आमतौर पर यह कार्य देता हूं जब यह एनोटेशन और प्रतिबिंब के लिए आता है। उसी समय, आप एक्जिक्यूटर्स , थ्रेडपूल एक्ज़ीक्यूटर और अन्य के बारे में बात कर सकते हैं।

टास्क: पूर्णांक पैरामीटर के साथ

अपना रिपीट एनोटेशन बनाएं ।
वर्ग का विस्तार ThreadPoolExecutor और ओवरराइड विधि निष्पादित इस प्रकार है: यदि का एक उदाहरण Runnable साथ टिप्पणी की जाती है दोहराएँ , तो इसकी विधि रन निष्पादित किया जाता है कई बार (संख्या में पैरामीटर द्वारा निर्दिष्ट दोहराएँ )।

अर्थात्, यह वर्ग लिखकर:

 @Repeat(3) class MyRunnable implements Runnable{ @Override public void run() { System.out.println("Hello!"); } }

और इसका उपयोग कर:

 public static void main(String[] strings) { CustomThreadPoolExecutor customThreadPoolExecutor = new CustomThreadPoolExecutor(10); customThreadPoolExecutor.execute(new MyRunnable()); }

हमें देखना चाहिए:

 Hello! Hello! Hello!

समाधान:

 @Retention(RetentionPolicy.RUNTIME) @interface Repeat { int value(); } class CustomThreadPoolExecutor extends ThreadPoolExecutor { public CustomThreadPoolExecutor(int corePoolSize) { // why Integer.MAX_VALUE, 0m and TimeUnit.MILLISECONDS? // see Executors.newFixedThreadPool(int nThreads) super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>()); } @Override public void execute(Runnable command) { if (command != null) { Class<? extends Runnable> runnableClass = command.getClass(); Repeat repeat = runnableClass.getAnnotation(Repeat.class); for (int i = 0; i < (repeat != null ? repeat.value() : 1); i++) { super.execute(command); } } } }

अंतिम और अन्य कार्य

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

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

10.0। सड़क प्रतिबंधों की संख्या

एक छोटा कार्य जो दर्शाता है कि व्यावहारिक समस्याओं को हल करने के लिए जावा को कैसे लागू किया जा सकता है।

डाटा तैयारी:
के साथ पोर्टल खुला डेटा के सेंट पीटर्सबर्ग लोड कार्यों की अवधि के लिए परिवहन की आवाजाही की सीमा पर डेटा के प्रारूप में सीएसवी ।

कार्य:

यह निर्धारित करना आवश्यक है कि एक निश्चित तिथि पर शहर में कितने सड़क प्रतिबंध लागू थे।

कार्यक्रम दो मापदंडों को तर्क के रूप में लेता है:

डेटा फ़ाइल के लिए पथ
तिथि

यह है, यह इस प्रकार शुरू होता है:

 java TrafficBlocks "PATH_TO_CSV_FILE" dd.MM.yyyy

इस तिथि पर लागू यातायात प्रतिबंधों की संख्या में कटौती करना आवश्यक है।

अनुकरणीय एल्गोरिथ्म

प्रक्रिया तर्क कमांड लाइन से होकर गुजरे
फ़ाइल लाइन लाइन द्वारा पढ़ें
स्ट्रिंग पार्स (देखें। Https://stackoverflow.com/questions/15738918/splitting-a-csv-file-with-quotes-as-text-delimiter-using-string-split )
किसी स्ट्रिंग से दिनांक प्राप्त करने के लिए, आप SimpleDateFormat का उपयोग कर सकते हैं
तारीखों की तुलना करें

वैसे, सभी समय के लिए केवल एक व्यक्ति ने देखा कि डेटा (yyyMMdd) में दिनांक स्वरूप ऐसा है कि उन्हें पार्स नहीं किया जा सकता है, लेकिन तार की तुलना में। तो समाधान को सरल बनाया जा सकता है। मैं इस कार्य को दिनांक, कैलेंडर, DateFormat के बारे में बात करने के बाद देता हूं, इसलिए मैं इस सरलीकरण के बारे में बात कर रहा हूं जब उन्होंने पहले ही सब कुछ लिखा था।

मैं यहां कोई समाधान नहीं लाता, वे कई अलग-अलग हो सकते हैं और प्रत्येक को व्यक्तिगत रूप से देखा जाना चाहिए।

10.1।विकिपीडिया खोज। कंसोल प्रोग्राम में

कार्य:

एक प्रोग्राम लिखें, जो कंसोल से खोज क्वेरी को पढ़ता है और विकिपीडिया पर खोज परिणाम प्रदर्शित करता है। कार्य को 4 चरणों में विभाजित किया गया है:

अनुरोध पढ़ें
सर्वर से अनुरोध करें
उत्तर को पार्स करें
प्रिंट परिणाम

पहले और चौथे बिंदु को बहुत स्पष्टीकरण की आवश्यकता नहीं है, आइए हम सर्वर के अनुरोध पर ध्यान दें।

इस कार्य को भी कई चरणों में विभाजित किया जा सकता है:

अनुरोध जनरेशन
सर्वर का अनुरोध
प्रतिक्रिया प्रसंस्करण के लिए तैयारी कर रहा है
प्रतिक्रिया प्रसंस्करण

आइए इस पर अधिक विस्तार से विचार करें: एपीआई

अनुरोध पीढ़ी
बिना चाबी के खोज क्वेरी करने की क्षमता प्रदान करती है। इस तरह, लगभग:

 https://ru.wikipedia.org/w/api.php?action=query&list=search&utf8=&format=json&srsearch="Java"

आप इस लिंक को एक ब्राउज़र में खोल सकते हैं और अनुरोध के परिणाम को देख सकते हैं।
हालाँकि, सफल होने के अनुरोध के लिए, आपको लिंक से अमान्य वर्णों को हटा देना चाहिए, अर्थात् , प्रतिशत-एन्कोडिंग करें , जो URL एनकोडिंग भी है।
ऐसा करने के लिए, जावा में, आप इस तरह URLEncoder वर्ग में स्थिर एनकोड विधि का उपयोग कर सकते हैं :

 street = URLEncoder.encode(street, "UTF-8");

यह बात है, URL तैयार है! सर्वर से अनुरोध करने के लिए यह अभी भी बना हुआ है ... सर्वर से

अनुरोध
करें GET और POST अनुरोधों के लिए, आप HttpURLConnection वर्ग का उपयोग कर सकते हैं । यह सबसे सरल है। बस बनाएं, एक कनेक्शन खोलें और एक इनपुटस्ट्रीम प्राप्त करें । हमें इसे पढ़ना भी नहीं है, हमारे लिए Gson करेगा ।
आप रेट्रोफिट , या कुछ समान का उपयोग भी कर सकते हैं ।

प्रतिक्रिया संसाधित करने की तैयारी
सर्वर JSON प्रारूप में डेटा देता है ।
लेकिन हमें इसे मैन्युअल रूप से पार्स करने की आवश्यकता नहीं है, इसके लिए Google से एक Gson लाइब्रेरी है।
उदाहरण यहाँ हैं:
https://github.com/google/gson
https://habrahabr.ru/company/naumen/blog/228279/

यदि समय बचा है, तो आप खोज के दौरान चुने गए लेख की रसीद लिख सकते हैं और इसी तरह।

10.2। अंतिम कार्य - HTTP के माध्यम से फ़ाइलों को डाउनलोड करने के लिए कंसोल उपयोगिता

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

10.3। अंतिम कार्य - मौसम टेलीग्राम-बॉट

कार्य:

टेलीग्राम के लिए एक बॉट लिखें, जो होगा:

.
, . /subscribe. (/unsubscribe).

पूर्वानुमान प्राप्त करने के लिए आप https://openweathermap.org/api का उपयोग कर सकते हैं ।

यह कार्य नई तकनीक (बॉट-अपी) और विभिन्न पुस्तकालयों को समझने की क्षमता और क्षमता पर है। और आपको वीपीएन सेट करने की आवश्यकता है! और आपको कोड लिखना होगा, बिल्कुल।

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

10.4। अंतिम कार्य - लिखावट की मान्यता

उद्देश्य:

हस्तलिखित संख्याओं को वर्गीकृत करने के लिए एक कार्यक्रम लागू करें।
यह कार्य पहले से ही एल्गोरिदम के कार्यान्वयन पर केंद्रित है, उन लोगों को समझने की क्षमता। आमतौर पर छात्रों के लिए कोड बहुत संरचित नहीं होता है।

कार्य का विवरण
अध्ययन किए जाने वाले डेटा सेट के रूप में, हस्तलिखित अंकों की छवियों के आधार MNIST का उपयोग किया जाएगा । इस डेटाबेस में छवियों का रिज़ॉल्यूशन 28x28 है और इसे ग्रेस्केल मानों के एक सेट के रूप में संग्रहीत किया जाता है। पूरे डेटाबेस को दो भागों में विभाजित किया गया है: प्रशिक्षण, जिसमें 50,000 चित्र शामिल हैं, और परीक्षण - 10,000 चित्र।

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

आवश्यकताएँ आपको

एक प्रोग्राम लिखना होगा जो हस्तलिखित संख्याओं को पहचान लेगा। प्रशिक्षण के लिए डेटा के साथ एक निश्चित वर्ग को शुरू करना और एकल छवि को पहचानने के लिए एक विधि प्रदान करना संभव होना चाहिए।

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

इसके साथ ही

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

कुछ और शब्द

यदि आपके पास शांत कार्य हैं जो आप छात्रों को दे सकते हैं (एक अनुमानित समाधान समय एक या दो घंटे है), तो उन्हें टिप्पणियों में साझा करें।

जावा प्रैक्टिकल टास्क - पाठ्यक्रम और अन्य गतिविधियों के लिए